home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / util / misc / frodo.lha / src / 6510.asm < prev    next >
Assembly Source File  |  1995-01-25  |  57KB  |  3,066 lines
  1. *
  2. * 6510.asm - 6510-Emulation (eigener Task)
  3. *
  4. * Copyright (C) 1994-1995 by Christian Bauer
  5. *
  6.  
  7. *
  8. * Anmerkungen:
  9. * ------------
  10. *
  11. * Register d0/d1 - WICHTIG:
  12. *  - Der Emulator geht davon aus, daß die MSWs von d0 und d1 immer Null
  13. *    sind. Denn dadurch kann das C64-RAM mittels (RAMPTR,d0.l) ohne
  14. *    Vorzeichen indiziert angesprochen werden.
  15. *  - Die Makros Read#?Zero#? und Read#?Ind#? gehen zusätlich davon aus,
  16. *    daß nur das untere Byte von d0 Null ist, da diese Makros immer nur
  17. *    am Anfang eines Befehls stehen und d0 vom Next-Makro noch gelöscht
  18. *    ist
  19. *
  20. * Speicherkonfigurationen:
  21. *
  22. * $01  $a000-$bfff  $d000-$dfff  $e000-$ffff
  23. * -----------------------------------------------
  24. *  0       RAM          RAM          RAM
  25. *  1       RAM       Char-ROM        RAM
  26. *  2       RAM       Char-ROM    Kernal-ROM
  27. *  3    Basic-ROM    Char-ROM    Kernal-ROM
  28. *  4       RAM          RAM          RAM
  29. *  5       RAM          I/O          RAM
  30. *  6       RAM          I/O      Kernal-ROM
  31. *  7    Basic-ROM       I/O      Kernal-ROM
  32. *
  33. * Zugriff auf den C64-Speicher:
  34. *  - Fast alle Speicherzugriffe laufen über die ReadByte/WriteByte-Makros,
  35. *    die die eingestellte Speicherkonfiguration dadurch berücksichtigen,
  36. *    daß die oberen 8 Adreßbits als Index in eine Sprungtabelle
  37. *    (ReadTab/WriteTab) dienen, die Zeiger auf die ReadByte*/WriteByte*-
  38. *    Routinen enthalten, über die der tatsächliche Zugriff erfolgt.
  39. *    Für jede der 8 Speicherkonfigurationen existiert jeweils eine solche
  40. *    Tabelle Bei einer Änderung der Speicherkonfiguration (NewConfig)
  41. *    werden die Zeiger auf die Tabellen (RDTAB/WRTAB) geändert.
  42. *  - Das LESEN aus der Zero-Page geschieht immer direkt,
  43. *    da dort keine Register liegen ($01 wird auch im RAM abgelegt)
  44. *  - Beim Schreiben in die Zero-Page wird nur auf $00/$01 getestet,
  45. *    ansonsten direkt zugegriffen
  46. *  - Der Stack wird immer direkt angesprochen
  47. *  - Die ReadByte-Routinen dürfen nur d0-d1/a0 verändern.
  48. *    a1 enthält die Rücksprungadresse, die Routinen müssen also mit
  49. *    "jmp (a1)" enden.
  50. *  - Die WriteByte-Routinen dürfen nur d0-d1/a0-a1 verändern
  51. *
  52. * Programmzähler:
  53. *  - Aus Geschwindigkeitsgründen wird der PC durch einen 32-Bit-
  54. *    Amiga-Zeiger repräsentiert und über diesen direkt auf den
  55. *    Speicher zugegriffen (und nicht über ReadByte). Bei einem
  56. *    Sprungbefehl wird aus dem 16-Bit Sprungziel und der aktuellen
  57. *    Speicherkonfiguration die neue 32-Bit-Adresse berechnet,
  58. *    indem ähnlich zur ReadTab die oberen 8 Bit des Sprungziels
  59. *    als Index in die JumpTab verwendet werden. Die darüber aufgerufenen
  60. *    Routinen führen die Umrechnung durch.
  61. *  - Durch die Art, wie das Hauptprogramm den Speicher anfordert,
  62. *    entsprechen die unteren 16 Bit des 32-Bit-PCs immer der
  63. *    16-Bit-C64-Adresse. Das erleichtert erheblich das Ablegen des
  64. *    PC auf dem Stack, da dazu einfach nur die unteren 16 Bit
  65. *    genommen werden müssen (ansonsten müßte man je nach RAM/ROM-
  66. *    Bereich erst die jeweilige Basisadresse subtrahieren).
  67. *  - Durch diese Art der PC-Verwaltung bestehen folgende Inkompatibilitäten:
  68. *     - Es gibt keinen Wraparound über Adresse $ffff/$0000 hinweg
  69. *     - Ein Branch oder ein Hineinlaufen in einen anderen Speicherbereich
  70. *       (z.B. RAM->ROM) funktioniert nicht. Das sollte allerdings kein
  71. *       Problem darstellen.
  72. *     - Ein Sprung in den I/O-Bereich ist z.Z. nicht möglich
  73. *
  74. * Condition-Codes:
  75. *  - Die Emulation verwendet zwei Register, um die Prozessorflags zu
  76. *    speichern: RCCR und RP.
  77. *  - RCCR ist ein Abbild des 680x0-CCR und wird nach den entsprechenden
  78. *    Operationen mit "move ccr,RCCR" gelesen. Von RCCR werden nur das N-
  79. *    und das Z-Flag verwendet.
  80. *  - Die einzigen Opcodes, die V ändern, sind ADC, SBC, CLV, PLP und RTI.
  81. *    Darum wird das V-Flag nicht aus dem 680x0-V-Flag erzeugt, sondern
  82. *    gegebenenfalls von Hand gesetzt.
  83. *  - Im oberen Byte (Bit 8-15) von RP sind die 6510-Flags V,B,D und I
  84. *    in der selben Anordnung wie beim 6510 gespeichert. Das untere Byte
  85. *    enthält in Bit 0 das Carry-Flag in 6510-Interpretation (bei SBC und
  86. *    CMP/CPX/CPY inverse Bedeutung zum 680x0), das bei den entsprechenden
  87. *    Opcodes aus dem CCR gelesen (und ggf. invertiert) wird. Der Einfachheit
  88. *    halber wird immer das ganze untere Byte von CCR gelesen, da nur Bit 0
  89. *    interessant ist.
  90. *
  91. * Opcode-Ausführung:
  92. *  - Es gibt keine Fetch-Decode-Schleife, sondern jede Opcode-Routine
  93. *    enthält am Schluß den Code, der den nächsten Befehl ausführt
  94. *    ("Next"-Makro).
  95. *  - Die Verzweigung in die einzelnen Opcode-Routinen geschieht über
  96. *    eine Sprungtabelle, die OpcodeTable. Das Register OPTABPTR enthält
  97. *    einen Zeiger auf diese Tabelle (vor der Tabelle steht noch der
  98. *    Zyklenzähler, auf den so schneller zugegriffen werden kann).
  99. *
  100. * Zyklenzähler/Periodic/Interrupts:
  101. *  - Die Variable CyclesLeft (erreichbar über (OPTABPTR)) enthält die
  102. *    Anzahl Zyklen, die dem 6510 in der augenblicklichen Rasterzeile noch
  103. *    zur Verfügung stehen
  104. *  - Nach jeder Opcode-Ausführung wird dieser Zähler um die Zyklenzahl
  105. *    des gerade ausgeführten Befehls erniedrigt. Dazu wird dem Next-Makro
  106. *    die Anzahl Zyklen übergeben. Unterschreitet der Zähler Null, wird
  107. *    die Routine "Periodic" aufgerufen.
  108. *  - In dieser Routine werden die Unterroutinen von VIC und CIA
  109. *    ausgeführt, die die Aktionen für eine Rasterzeile durchführen
  110. *    (VIC (Periodic6569): Eine Bildschirmzeile aufbauen, CIA
  111. *    (Periodic6526): Timer zählen)
  112. *  - In Periodic6569 wird der Zyklenzähler neu gesetzt (der Wert hängt
  113. *    davon ab, ob eine Bad Line stattfand oder nicht)
  114. *
  115. * Interrupts:
  116. *  - Die Haupt-Interruptquellen sind VIC und CIA, daher prüft der
  117. *    Emulator das Auftreten eines Interrupts im Rahmen der Periodic-
  118. *    Routine
  119. *  - Es gibt folgende Interrupt-Möglichkeiten (Prioritäten):
  120. *     - RESET, Sprung nach ($FFFC) oder 6510-Task beenden (RESETIsEXIT-Flag)
  121. *     - NMI, Sprung nach ($FFFA)
  122. *     - VIC-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  123. *     - CIA-IRQ, I-Flag wird geprüft, Sprung nach ($FFFE)
  124. *  - Die Aufteilung in VIC- und CIA-IRQ erleichtert die Handhabung, wenn
  125. *    beide IRQs gleichzeitig auftreten
  126. *  - Die einzige Möglichkeit, außerhalb des Periodic einen Interrupt
  127. *    auszulösen, ist das Löschen des I-Flags, wenn ein IRQ ansteht.
  128. *    Die Opcode-Routinen für PLP, RTI und CLI enthalten deswegen besondere
  129. *    Abfragen, die ggf. in den Interrupt-Handler verzweigen.
  130. *
  131. * Erweiterungen:
  132. *  - Über den Opcode $f2 sind die 1541-Routinen implementiert. Dem Opcode
  133. *    folgt ein Byte, das die Nummer der auzurufenden Routine angibt.
  134. *
  135. * Inkompatibilitäten:
  136. *  - ($ff),Y-Adressierung liest das zweite Byte der indirekten Adresse
  137. *    aus $0100 statt $0000. Dies geschieht aus Geschwindigkeitsgründen,
  138. *    der korrekte Code ist im Makro ReadAdrIndY auskommentiert.
  139. *  - In der Verwaltung des PCs bestehen einige Ungenauigkeiten (siehe
  140. *    Abschnitt "Programmzähler")
  141. *  - RMW-Befehle sollten erst die Originaldaten und dann die geänderten
  142. *    schreiben, aber das spielt nur eine Rolle für Register wie das
  143. *    VIC-IRQFLAG-Register, das in 6569.asm deswegen speziell behandelt wird
  144. *  - Zyklen werden nur für ganze Befehle gezählt, Extra-Zyklen für
  145. *    Seitenüberschreitungen werden nicht berechnet (dies betrifft die
  146. *    Adressierungsarten xxxx,X xxxx,Y (xx),Y und die Branch-Befehle)
  147. *  - ADC und SBC im Dezimalmodus setzen die Flags nicht korrekt
  148. *  - RRA und ISB berücksichtigen das D-Flag nicht
  149. *
  150.  
  151.  
  152.         MACHINE    68020
  153.  
  154.         INCLUDE    "exec/types.i"
  155.         INCLUDE    "exec/macros.i"
  156.         INCLUDE    "exec/execbase.i"
  157.         INCLUDE    "exec/nodes.i"
  158.         INCLUDE    "dos/dos.i"
  159.         INCLUDE    "dos/dostags.i"
  160.         INCLUDE    "Frodo_rev.i"
  161.  
  162.         XREF    _SysBase
  163.         XREF    _DOSBase
  164.         XREF    _IntuitionBase
  165.  
  166.         XDEF    TheRAM        ;Main.asm
  167.         XDEF    TheBasic
  168.         XDEF    TheKernal
  169.         XDEF    TheChar
  170.         XDEF    TheColor
  171.         XREF    MainTask
  172.  
  173.         XREF    ReadFrom6526A    ;6526.asm
  174.         XREF    ReadFrom6526B
  175.         XREF    WriteTo6526A
  176.         XREF    WriteTo6526B
  177.         XREF    Periodic6526
  178.         XREF    Reset6526
  179.  
  180.         XREF    Init6569    ;6569.asm
  181.         XREF    Exit6569
  182.         XREF    ReadFrom6569
  183.         XREF    WriteTo6569
  184.         XREF    Periodic6569
  185.         XREF    AmigaToFront
  186.         XREF    EmulToFront
  187.  
  188.         XREF    ReadFrom6581    ;6581.asm
  189.         XREF    WriteTo6581
  190.         XREF    Reset6581
  191.  
  192.         XREF    IECOut        ;1541.asm
  193.         XREF    IECOutATN
  194.         XREF    IECOutSec
  195.         XREF    IECIn
  196.         XREF    IECSetATN
  197.         XREF    IECRelATN
  198.         XREF    IECTurnaround
  199.         XREF    IECRelease
  200.  
  201.         XDEF    Init6510
  202.         XDEF    Start6510
  203.         XDEF    Stop6510
  204.         XDEF    Pause6510
  205.         XDEF    Resume6510
  206.         XDEF    IntIsRESET
  207.         XDEF    IntIsNMI
  208.         XDEF    IntIsVICIRQ
  209.         XDEF    IntIsCIAIRQ
  210.         XDEF    DontPause
  211.         XDEF    CyclesLeft
  212.         XDEF    CPUTask
  213.         XDEF    Peri6569Cont
  214.         XDEF    Peri6526Cont
  215.  
  216.         SECTION    "CODE",CODE
  217.  
  218.  
  219. **
  220. ** Definitionen
  221. **
  222.  
  223. ; Bitdefinitionen für RP (6510-Statusregister)
  224. CarryBit    = 0    ;Carry (nach 6510-Definition)
  225. InterruptBit    = 10    ;Interrupts abgeschaltet
  226. InterruptMask    = $0400
  227. DecimalBit    = 11    ;Dezimalmodus
  228. DecimalMask    = $0800
  229. BreakBit    = 12    ;Break-Befehl (nur auf dem Stack)
  230. BreakMask    = $1000
  231. OverflowBit    = 14    ;Arith. Überlauf
  232. OverflowMask    = $4000
  233.  
  234. ; Registerbelegung (Achtung: In 1541.asm sind ebenfalls solche
  235. ;  Definitionen, die hiermit übereinstimmen müssen!)
  236. RA        EQUR    d2    ;A
  237. RX        EQUR    d3    ;X
  238. RY        EQUR    d4    ;Y
  239. RS        EQUR    d5    ;S (16-Bit, $01xx)
  240. RCCR        EQUR    d6    ;CCR, nur N und Z
  241. RP        EQUR    d7    ;Oberes Byte: 6510-Status ohne N,Z und C.
  242.                 ;Bit #0: Carry
  243. RDTAB        EQUR    a2    ;Zeiger auf ReadByte-Sprungtabelle
  244. WRTAB        EQUR    a3    ;Zeiger auf WriteByte-Sprungtabelle
  245.                 ;256*8*4+WRTAB zeigt auf JumpTab
  246. RAMPTR        EQUR    a4    ;Zeiger auf C64-RAM
  247. RPC        EQUR    a5    ;PC (32-Bit Amiga-Adresse, untere 16 Bit
  248.                 ;    stimmen mit C64-PC überein)
  249. OPTABPTR    EQUR    a6    ;Zeiger auf die Opcode-Dispatch-Tabelle
  250.                 ; und den Zyklenzähler
  251.  
  252.  
  253. *
  254. * Makros für Speicherzugriffe und Adreßberechnungen
  255. *
  256.  
  257. ; Ein C64-Byte lesen
  258. ; -> d0.w: Adresse
  259. ; <- d0.b: Byte
  260. ReadByte    MACRO
  261.         cmp.w    #$a000,d0    ;Unterhalb von $a000 ist nur Speicher
  262.         blo    \@1$
  263.         move.w    d0,d1
  264.         lsr.w    #8,d1
  265.         lea    \@2$(pc),a1    ;Ist hier schneller, weil sonst
  266.         move.l    (RDTAB,d1.w*4),a0 ;hinter dem jmp (a0) ein bra \@2$
  267.         jmp    (a0)        ;stehen müßte
  268. \@1$        move.b    (RAMPTR,d0.l),d0
  269. \@2$
  270.         ENDM
  271.  
  272. ; Ein C64-Wort lesen (Als Makro schneller)
  273. ; -> d0.w: Adresse
  274. ; <- d0.w: Wort (Bytefolge korrigiert)
  275. ReadWord    MACRO
  276.         move.l    d0,-(sp)    ;Adresse merken
  277.         ReadByte
  278.         move.b    d0,d1
  279.         move.l    (sp)+,d0    ;Adresse zurückholen
  280.         addq.w    #1,d0        ;Nächstes Byte
  281.         move.l    d1,-(sp)    ;Lo-Byte merken
  282.         ReadByte
  283.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  284.         move.l    (sp)+,d1
  285.         move.b    d1,d0        ;Lo-Byte dazunehmen
  286.         ENDM
  287.  
  288. ; Ein C64-Byte schreiben
  289. ; -> d0.w: Adresse (16 bit)
  290. ; -> d1.b: Byte
  291. ; Adresse steht dann in a1
  292. WriteByte    MACRO
  293.         cmp.w    #$a000,d0
  294.         blo    \@1$
  295.         move.l    d0,a1
  296.         lsr.w    #8,d0
  297.         move.l    (WRTAB,d0.w*4),a0
  298.         jsr    (a0)
  299.         bra    \@2$
  300. \@1$        move.b    d1,(RAMPTR,d0.l)
  301.         cmp.b    #2,d0
  302.         bhs    \@2$
  303.         NewConfig
  304. \@2$
  305.         ENDM
  306.  
  307. ; Ein C64-Wort am PC lesen und PC erhöhen
  308. ReadPCWord    MACRO
  309.         move.w    (RPC)+,d0
  310.         rol.w    #8,d0
  311.         ENDM
  312.  
  313. ; Relative Adressierung
  314. ReadByteRel    MACRO
  315.         move.b    (RPC)+,d0
  316.         ext.w    d0
  317.         ENDM
  318.  
  319. ; Absolute Adressierung
  320. ReadAdrAbs    MACRO
  321.         ReadPCWord
  322.         ENDM
  323.  
  324. ReadByteAbs    MACRO
  325.         ReadAdrAbs
  326.         ReadByte
  327.         ENDM
  328.  
  329. ; Indirekte Adressierung
  330. ReadAdrInd    MACRO
  331.         ReadPCWord
  332.         move.l    d0,-(sp)    ;Adresse merken
  333.         ReadByte
  334.         move.b    d0,d1
  335.         move.l    (sp)+,d0    ;Adresse zurückholen
  336.         addq.b    #1,d0        ;Nächstes Byte OHNE Page-Crossing
  337.         move.l    d1,-(sp)    ;Lo-Byte merken
  338.         ReadByte
  339.         lsl.w    #8,d0        ;Hi-Byte richtig schieben
  340.         move.l    (sp)+,d1
  341.         move.b    d1,d0        ;Lo-Byte dazunehmen
  342.         ENDM
  343.  
  344. ; Zero-Page Adressierung
  345. ReadAdrZero    MACRO
  346.         move.b    (RPC)+,d0
  347.         ENDM
  348.  
  349. ReadByteZero    MACRO    ;Register
  350.         ReadAdrZero
  351.         move.b    (RAMPTR,d0.w),\1
  352.         ENDM
  353.  
  354. ; Absolut,X
  355. ReadAdrAbsX    MACRO
  356.         ReadPCWord
  357.         add.w    RX,d0
  358.         ENDM
  359.  
  360. ReadByteAbsX    MACRO
  361.         ReadAdrAbsX
  362.         ReadByte
  363.         ENDM
  364.  
  365. ; Absolut,Y
  366. ReadAdrAbsY    MACRO
  367.         ReadPCWord
  368.         add.w    RY,d0
  369.         ENDM
  370.  
  371. ReadByteAbsY    MACRO
  372.         ReadAdrAbsY
  373.         ReadByte
  374.         ENDM
  375.  
  376. ; Zero-Page,X
  377. ReadAdrZeroX    MACRO
  378.         move.b    (RPC)+,d0
  379.         add.b    RX,d0
  380.         ENDM
  381.  
  382. ReadByteZeroX    MACRO    ;Register
  383.         ReadAdrZeroX
  384.         move.b    (RAMPTR,d0.w),\1
  385.         ENDM
  386.  
  387. ; Zero-Page,Y
  388. ReadAdrZeroY    MACRO
  389.         move.b    (RPC)+,d0
  390.         add.b    RY,d0
  391.         ENDM
  392.  
  393. ReadByteZeroY    MACRO    ;Register
  394.         ReadAdrZeroY
  395.         move.b    (RAMPTR,d0.w),\1
  396.         ENDM
  397.  
  398. ; (Ind,X)
  399. ReadAdrIndX    MACRO
  400.         move.b    (RPC)+,d0
  401.         add.b    RX,d0
  402.         move.b    (RAMPTR,d0.w),d1    ;LSB lesen
  403.         addq.b    #1,d0
  404.         move.b    (RAMPTR,d0.w),d0    ;MSB lesen
  405.         lsl.w    #8,d0
  406.         move.b    d1,d0            ;LSB einfügen
  407.         ENDM
  408.  
  409. ReadByteIndX    MACRO
  410.         ReadAdrIndX
  411.         ReadByte
  412.         ENDM
  413.  
  414. ; (Ind),Y
  415. ReadAdrIndY    MACRO
  416.         move.b    (RPC)+,d0
  417.  
  418. ;(Korrekt)    move.b    (RAMPTR,d0.w),d1    ;LSB lesen
  419. ;        addq.b    #1,d0
  420. ;        move.b    (RAMPTR,d0.w),d0    ;MSB lesen
  421. ;        lsl.w    #8,d0
  422. ;        move.b    d1,d0            ;LSB einfügen
  423.  
  424.         move.w    (RAMPTR,d0.w),d0    ;(Abgekürzt)
  425.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  426.  
  427.         add.w    RY,d0
  428.         ENDM
  429.  
  430. ReadByteIndY    MACRO
  431.         ReadAdrIndY
  432.         ReadByte
  433.         ENDM
  434.  
  435. ; Ein Byte (Arg1) auf den Stapel schieben
  436. PushByte    MACRO    ;Register
  437.         move.b    \1,(RAMPTR,RS.w)
  438.         subq.b    #1,RS
  439.         ENDM
  440.  
  441. ; PC auf Stack schieben
  442. PushPC        MACRO
  443.         move.w    RPC,d0
  444.         move.w    d0,d1
  445.         lsr.w    #8,d0
  446.         PushByte d0
  447.         PushByte d1
  448.         ENDM
  449.  
  450. ; PC+1 auf den Stack schieben
  451. PushPCPlus1    MACRO
  452.         move.w    RPC,d0
  453.         addq.w    #1,d0
  454.         move.w    d0,d1
  455.         lsr.w    #8,d0
  456.         PushByte    d0
  457.         PushByte    d1
  458.         ENDM
  459.  
  460. ; Status auf Stack schieben
  461. PushP        MACRO
  462.         move.w    RP,d0        ;6510-Status holen
  463.         lsr.w    #8,d0
  464.         and.b    #$5c,d0        ;V,B,D,I behalten
  465.         or.b    #$20,d0        ;1-Bit setzen
  466.         btst    #CarryBit,RP    ;C dazunehmen
  467.         beq    \@1$
  468.         or.b    #$01,d0
  469. \@1$        btst    #3,RCCR        ;N dazunehmen
  470.         beq    \@2$
  471.         or.b    #$80,d0
  472. \@2$        btst    #2,RCCR        ;Z dazunehmen
  473.         beq    \@3$
  474.         or.b    #$02,d0
  475. \@3$        PushByte d0
  476.         ENDM
  477.  
  478. ; Ein Byte vom Stapel nach Arg1 lesen
  479. PopByte        MACRO    ;Register
  480.         addq.b    #1,RS
  481.         move.b    (RAMPTR,RS.w),\1
  482.         ENDM
  483.  
  484. ; Status vom Stack holen
  485. PopP        MACRO
  486.         PopByte    d0
  487.         move    ccr,RCCR
  488.         and.b    #$08,RCCR    ;N holen
  489.         move.b    d0,RP
  490.         and.b    #$4c,RP        ;V,D,I behalten
  491.         lsl.w    #8,RP
  492.         btst    #1,d0        ;Z holen
  493.         beq    \@1$
  494.         or.b    #$04,RCCR
  495. \@1$        btst    #0,d0        ;C holen
  496.         beq    \@2$
  497.         or.b    #$01,RP
  498. \@2$
  499.         ENDM
  500.  
  501. ; PC setzen
  502. ; -> d0.w: 16-Bit-Adresse
  503. ; <- RPC.l: Amiga-Adresse
  504. Jump        MACRO
  505.         move.w    d0,d1
  506.         lsr.w    #8,d1
  507.         move.l    256*8*4(WRTAB,d1.w*4),a0
  508.         jsr    (a0)
  509.         ENDM
  510.  
  511. ; Nächsten Befehl ausführen
  512. Next        MACRO    ;Zyklenzahl
  513.     IFNE    \1
  514.         subq.w    #\1,(OPTABPTR)    ;Anzahl Zyklen abziehen
  515.         bmi    Periodic    ;Alle verbraucht: Periodic
  516.     ENDC
  517.  
  518.         moveq    #0,d0
  519.         move.b    (RPC)+,d0    ;Opcode lesen
  520.         move.l    4(OPTABPTR,d0.w*4),a0 ;Zeiger auf die Opcode-Routine holen
  521.         jmp    (a0)        ;Routine aufrufen
  522.         ENDM
  523.  
  524. ; Speicherkonfiguration anpassen
  525. NewConfig    MACRO
  526.         move.b    1(RAMPTR),d0    ;Config lesen
  527.         and.w    #7,d0        ;Relevante Bits maskieren
  528.         movem.l    (ConfigTab,pc,d0.w*8),RDTAB/WRTAB
  529.         ENDM
  530.  
  531. ; Ein C64-Byte in die Zero-Page schreiben und nächsten Befehl ausführen.
  532. ; Prüfen, ob sich die Speicherkonfiguration geändert hat.
  533. ; -> d0.w: Adresse (16 bit)
  534. ; -> Arg1: Byte
  535. WriteZeroNext    MACRO    ;Register, Zyklenzahl
  536.         move.b    \1,(RAMPTR,d0.w)
  537.         cmp.b    #2,d0
  538.         bhs    \@1$
  539.         NewConfig
  540. \@1$        Next    \2
  541.         ENDM
  542.  
  543.  
  544. **
  545. ** Emulation vorbereiten (Sprungtabellen aufbauen)
  546. **
  547.  
  548. ; ReadTabs aufbauen
  549. Init6510    lea    ReadTab0,a0        ;Alle mit RAM vorbelegen
  550.         move.w    #256*8-1,d0
  551. 1$        move.l    #ReadByteRAM,(a0)+
  552.         dbra    d0,1$
  553.  
  554.         lea    ReadTab3+160*4,a0    ;Basic-ROM
  555.         moveq    #31,d0
  556. 21$        move.l    #ReadByteBasic,(a0)+
  557.         dbra    d0,21$
  558.  
  559.         lea    ReadTab7+160*4,a0
  560.         moveq    #31,d0
  561. 22$        move.l    #ReadByteBasic,(a0)+
  562.         dbra    d0,22$
  563.  
  564.         lea    ReadTab2+224*4,a0    ;Kernal-ROM
  565.         moveq    #31,d0
  566. 31$        move.l    #ReadByteKernal,(a0)+
  567.         dbra    d0,31$
  568.  
  569.         lea    ReadTab3+224*4,a0
  570.         moveq    #31,d0
  571. 32$        move.l    #ReadByteKernal,(a0)+
  572.         dbra    d0,32$
  573.  
  574.         lea    ReadTab6+224*4,a0
  575.         moveq    #31,d0
  576. 33$        move.l    #ReadByteKernal,(a0)+
  577.         dbra    d0,33$
  578.  
  579.         lea    ReadTab7+224*4,a0
  580.         moveq    #31,d0
  581. 34$        move.l    #ReadByteKernal,(a0)+
  582.         dbra    d0,34$
  583.  
  584.         lea    ReadTab5+208*4,a0    ;I/O-Bereich
  585.         move.l    #ReadByteVIC,(a0)+
  586.         move.l    #ReadByteVIC,(a0)+
  587.         move.l    #ReadByteVIC,(a0)+
  588.         move.l    #ReadByteVIC,(a0)+
  589.         move.l    #ReadByteSID,(a0)+
  590.         move.l    #ReadByteSID,(a0)+
  591.         move.l    #ReadByteSID,(a0)+
  592.         move.l    #ReadByteSID,(a0)+
  593.         move.l    #ReadByteColor,(a0)+
  594.         move.l    #ReadByteColor,(a0)+
  595.         move.l    #ReadByteColor,(a0)+
  596.         move.l    #ReadByteColor,(a0)+
  597.         move.l    #ReadByteCIA1,(a0)+
  598.         move.l    #ReadByteCIA2,(a0)+
  599.         move.l    #ReadByteUndef,(a0)+
  600.         move.l    #ReadByteUndef,(a0)
  601.  
  602.         lea    ReadTab6+208*4,a0
  603.         move.l    #ReadByteVIC,(a0)+
  604.         move.l    #ReadByteVIC,(a0)+
  605.         move.l    #ReadByteVIC,(a0)+
  606.         move.l    #ReadByteVIC,(a0)+
  607.         move.l    #ReadByteSID,(a0)+
  608.         move.l    #ReadByteSID,(a0)+
  609.         move.l    #ReadByteSID,(a0)+
  610.         move.l    #ReadByteSID,(a0)+
  611.         move.l    #ReadByteColor,(a0)+
  612.         move.l    #ReadByteColor,(a0)+
  613.         move.l    #ReadByteColor,(a0)+
  614.         move.l    #ReadByteColor,(a0)+
  615.         move.l    #ReadByteCIA1,(a0)+
  616.         move.l    #ReadByteCIA2,(a0)+
  617.         move.l    #ReadByteUndef,(a0)+
  618.         move.l    #ReadByteUndef,(a0)
  619.  
  620.         lea    ReadTab7+208*4,a0
  621.         move.l    #ReadByteVIC,(a0)+
  622.         move.l    #ReadByteVIC,(a0)+
  623.         move.l    #ReadByteVIC,(a0)+
  624.         move.l    #ReadByteVIC,(a0)+
  625.         move.l    #ReadByteSID,(a0)+
  626.         move.l    #ReadByteSID,(a0)+
  627.         move.l    #ReadByteSID,(a0)+
  628.         move.l    #ReadByteSID,(a0)+
  629.         move.l    #ReadByteColor,(a0)+
  630.         move.l    #ReadByteColor,(a0)+
  631.         move.l    #ReadByteColor,(a0)+
  632.         move.l    #ReadByteColor,(a0)+
  633.         move.l    #ReadByteCIA1,(a0)+
  634.         move.l    #ReadByteCIA2,(a0)+
  635.         move.l    #ReadByteUndef,(a0)+
  636.         move.l    #ReadByteUndef,(a0)
  637.  
  638.         lea    ReadTab1+208*4,a0    ;Char-ROM
  639.         moveq    #15,d0
  640. 41$        move.l    #ReadByteChar,(a0)+
  641.         dbra    d0,41$
  642.  
  643.         lea    ReadTab2+208*4,a0
  644.         moveq    #15,d0
  645. 42$        move.l    #ReadByteChar,(a0)+
  646.         dbra    d0,42$
  647.  
  648.         lea    ReadTab3+208*4,a0
  649.         moveq    #15,d0
  650. 43$        move.l    #ReadByteChar,(a0)+
  651.         dbra    d0,43$
  652.  
  653. ; WriteTabs aufbauen
  654.         lea    WriteTab0,a0        ;Alle mit RAM vorbelegen
  655.         move.w    #256*8-1,d0
  656. 5$        move.l    #WriteByteRAM,(a0)+
  657.         dbra    d0,5$
  658.  
  659.         move.l    #WriteBytePage0,WriteTab0 ;Zeropage immer speziell
  660.         move.l    #WriteBytePage0,WriteTab1
  661.         move.l    #WriteBytePage0,WriteTab2
  662.         move.l    #WriteBytePage0,WriteTab3
  663.         move.l    #WriteBytePage0,WriteTab4
  664.         move.l    #WriteBytePage0,WriteTab5
  665.         move.l    #WriteBytePage0,WriteTab6
  666.         move.l    #WriteBytePage0,WriteTab7
  667.  
  668.         lea    WriteTab5+208*4,a0    ;I/O-Bereich
  669.         move.l    #WriteByteVIC,(a0)+
  670.         move.l    #WriteByteVIC,(a0)+
  671.         move.l    #WriteByteVIC,(a0)+
  672.         move.l    #WriteByteVIC,(a0)+
  673.         move.l    #WriteByteSID,(a0)+
  674.         move.l    #WriteByteSID,(a0)+
  675.         move.l    #WriteByteSID,(a0)+
  676.         move.l    #WriteByteSID,(a0)+
  677.         move.l    #WriteByteColor,(a0)+
  678.         move.l    #WriteByteColor,(a0)+
  679.         move.l    #WriteByteColor,(a0)+
  680.         move.l    #WriteByteColor,(a0)+
  681.         move.l    #WriteByteCIA1,(a0)+
  682.         move.l    #WriteByteCIA2,(a0)+
  683.         move.l    #WriteByteUndef,(a0)+
  684.         move.l    #WriteByteUndef,(a0)
  685.  
  686.         lea    WriteTab6+208*4,a0
  687.         move.l    #WriteByteVIC,(a0)+
  688.         move.l    #WriteByteVIC,(a0)+
  689.         move.l    #WriteByteVIC,(a0)+
  690.         move.l    #WriteByteVIC,(a0)+
  691.         move.l    #WriteByteSID,(a0)+
  692.         move.l    #WriteByteSID,(a0)+
  693.         move.l    #WriteByteSID,(a0)+
  694.         move.l    #WriteByteSID,(a0)+
  695.         move.l    #WriteByteColor,(a0)+
  696.         move.l    #WriteByteColor,(a0)+
  697.         move.l    #WriteByteColor,(a0)+
  698.         move.l    #WriteByteColor,(a0)+
  699.         move.l    #WriteByteCIA1,(a0)+
  700.         move.l    #WriteByteCIA2,(a0)+
  701.         move.l    #WriteByteUndef,(a0)+
  702.         move.l    #WriteByteUndef,(a0)
  703.  
  704.         lea    WriteTab7+208*4,a0
  705.         move.l    #WriteByteVIC,(a0)+
  706.         move.l    #WriteByteVIC,(a0)+
  707.         move.l    #WriteByteVIC,(a0)+
  708.         move.l    #WriteByteVIC,(a0)+
  709.         move.l    #WriteByteSID,(a0)+
  710.         move.l    #WriteByteSID,(a0)+
  711.         move.l    #WriteByteSID,(a0)+
  712.         move.l    #WriteByteSID,(a0)+
  713.         move.l    #WriteByteColor,(a0)+
  714.         move.l    #WriteByteColor,(a0)+
  715.         move.l    #WriteByteColor,(a0)+
  716.         move.l    #WriteByteColor,(a0)+
  717.         move.l    #WriteByteCIA1,(a0)+
  718.         move.l    #WriteByteCIA2,(a0)+
  719.         move.l    #WriteByteUndef,(a0)+
  720.         move.l    #WriteByteUndef,(a0)
  721.  
  722. ; JumpTabs aufbauen
  723.         lea    JumpTab0,a0        ;Alle mit RAM vorbelegen
  724.         move.w    #256*8-1,d0
  725. 6$        move.l    #JumpToRAM,(a0)+
  726.         dbra    d0,6$
  727.  
  728.         lea    JumpTab3+160*4,a0    ;Basic-ROM
  729.         moveq    #31,d0
  730. 71$        move.l    #JumpToBasic,(a0)+
  731.         dbra    d0,71$
  732.  
  733.         lea    JumpTab7+160*4,a0
  734.         moveq    #31,d0
  735. 72$        move.l    #JumpToBasic,(a0)+
  736.         dbra    d0,72$
  737.  
  738.         lea    JumpTab2+224*4,a0    ;Kernal-ROM
  739.         moveq    #31,d0
  740. 81$        move.l    #JumpToKernal,(a0)+
  741.         dbra    d0,81$
  742.  
  743.         lea    JumpTab3+224*4,a0
  744.         moveq    #31,d0
  745. 82$        move.l    #JumpToKernal,(a0)+
  746.         dbra    d0,82$
  747.  
  748.         lea    JumpTab6+224*4,a0
  749.         moveq    #31,d0
  750. 83$        move.l    #JumpToKernal,(a0)+
  751.         dbra    d0,83$
  752.  
  753.         lea    JumpTab7+224*4,a0
  754.         moveq    #31,d0
  755. 84$        move.l    #JumpToKernal,(a0)+
  756.         dbra    d0,84$
  757.  
  758.         lea    JumpTab1+208*4,a0    ;Char-ROM
  759.         moveq    #15,d0
  760. 85$        move.l    #JumpToChar,(a0)+
  761.         dbra    d0,85$
  762.  
  763.         lea    JumpTab2+208*4,a0
  764.         moveq    #15,d0
  765. 86$        move.l    #JumpToChar,(a0)+
  766.         dbra    d0,86$
  767.  
  768.         lea    JumpTab3+208*4,a0
  769.         moveq    #15,d0
  770. 87$        move.l    #JumpToChar,(a0)+
  771.         dbra    d0,87$
  772.  
  773.         lea    JumpTab5+208*4,a0    ;I/O-Bereich
  774.         moveq    #15,d0
  775. 88$        move.l    #JumpToIO,(a0)+
  776.         dbra    d0,88$
  777.  
  778.         lea    JumpTab6+208*4,a0
  779.         moveq    #15,d0
  780. 89$        move.l    #JumpToIO,(a0)+
  781.         dbra    d0,89$
  782.  
  783.         lea    JumpTab7+208*4,a0
  784.         moveq    #15,d0
  785. 810$        move.l    #JumpToIO,(a0)+
  786.         dbra    d0,810$
  787.         rts
  788.  
  789.  
  790. **
  791. ** 6510-Task starten
  792. ** Rückgabe: d0#0 = Fehler
  793. **
  794.  
  795. ; Signal einrichten
  796. Start6510    move.l    _SysBase,a6
  797.         moveq    #-1,d0
  798.         JSRLIB    AllocSignal
  799.         move.b    d0,ReadySig
  800.         moveq    #0,d1
  801.         bset    d0,d1
  802.         move.l    d1,ReadySet
  803.  
  804. ; Task starten
  805.         move.l    _DOSBase,a6
  806.         move.l    #ProcTags,d1
  807.         JSRLIB    CreateNewProc
  808.         move.l    d0,CPUProc
  809.         beq    1$
  810.  
  811. ; Auf Signal warten
  812.         move.l    _SysBase,a6
  813.         move.l    ReadySet,d0
  814.         JSRLIB    Wait
  815.         moveq    #0,d0        ;Alles OK
  816.         rts
  817.  
  818. ; Fehler aufgetreten
  819. 1$        moveq    #-1,d0
  820.         rts
  821.  
  822.  
  823. **
  824. ** 6510-Task stoppen
  825. **
  826.  
  827. ; Task stoppen
  828. Stop6510    move.l    _SysBase,a6
  829.         tst.l    CPUProc(pc)
  830.         beq    1$
  831.         st.b    RESETIsEXIT    ;EXIT-Reset auslösen
  832.         st.b    IntIsRESET
  833.         move.l    ReadySet,d0
  834.         JSRLIB    Wait
  835.  
  836. ; Signal freigeben
  837. 1$        move.b    ReadySig,d0
  838.         JSRLIB    FreeSignal
  839.         rts
  840.  
  841.  
  842. **
  843. ** 6510-Task anhalten
  844. **
  845.  
  846. Pause6510    move.l    _SysBase,a6
  847.         JSRLIB    Forbid
  848.  
  849. 2$        tst.w    DontPause(pc)    ;Pause erlaubt?
  850.         beq    1$
  851.         move.l    _DOSBase,a6    ;Nein, kurz warten und dann
  852.         moveq    #1,d1        ;nochmal probieren
  853.         JSRLIB    Delay
  854.         bra    2$
  855.  
  856. 1$        move.l    _SysBase,a6    ;OK, Task entfernen
  857.         move.l    CPUTask,a1
  858.         JSRLIB    Remove
  859.         JSRLIB    Permit
  860.         rts
  861.  
  862.  
  863. **
  864. ** 6510-Task fortsetzen
  865. **
  866.  
  867. Resume6510    move.l    _SysBase,a6
  868.         JSRLIB    Forbid
  869.         lea    TaskReady(a6),a0
  870.         move.l    CPUTask,a1    ;Task wieder einhängen
  871.         JSRLIB    Enqueue
  872.         JSRLIB    Permit
  873.         rts
  874.  
  875.  
  876. **
  877. ** 6510-Emulator
  878. **
  879. ** Register:
  880. **  d0: Scratch (Oberes Wort muß IMMER Null sein!)
  881. **  d1: Scratch (Oberes Wort muß IMMER Null sein!)
  882. **
  883.  
  884. ; Task ermitteln
  885. CPUTaskProc    move.l    _SysBase,a6
  886.         sub.l    a1,a1
  887.         JSRLIB    FindTask
  888.         move.l    d0,CPUTask
  889.  
  890. ; 6569 initialisieren
  891.         bsr    Init6569
  892.  
  893. ; Signal an den Emulator schicken
  894.         move.l    _SysBase,a6
  895.         move.l    MainTask,a1
  896.         move.l    ReadySet,d0
  897.         JSRLIB    Signal
  898.  
  899. ; Variablen initilisieren
  900.         clr.l    Interrupt
  901.         clr.b    RESETIsEXIT
  902.         clr.w    DontPause
  903.         move.w    #63,CyclesLeft
  904.  
  905. ; Speicherkonfiguration initialisieren
  906.         move.l    TheRAM,RAMPTR
  907.         move.w    #$ff07,(RAMPTR)
  908.         NewConfig
  909.  
  910. ; Register setzen
  911.         moveq    #0,d0
  912.         moveq    #0,d1
  913.         moveq    #0,RA
  914.         moveq    #0,RX
  915.         moveq    #0,RY
  916.         move.l    #$01ff,RS
  917.         moveq    #0,RCCR
  918.         move.l    #InterruptMask,RP
  919.         lea    OpcodeTable,OPTABPTR
  920.  
  921. ; Reset-Vektor lesen, PC setzen und ersten Befehl ausführen
  922.         move.w    #$fffc,d0
  923.         ReadWord
  924.         Jump
  925.         Next    0
  926.  
  927. ; Unbekannten Opcode entdeckt: Requester darstellen
  928. IllegalOp    move.w    #-1,DontPause        ;Nicht hier anhalten
  929.         movem.l    a2-a6,-(sp)
  930.  
  931.         and.w    #$00ff,d0        ;Opcode
  932.         move.w    d0,RequestStream
  933.         move.l    RPC,d0            ;und PC anzeigen
  934.         subq.w    #1,d0
  935.         move.w    d0,RequestStream+2
  936.  
  937.         bsr    AmigaToFront
  938.  
  939.         move.l    _IntuitionBase,a6
  940.         sub.l    a0,a0
  941.         lea    IllegalOpReq,a1
  942.         move.l    a0,a2
  943.         lea    RequestStream,a3
  944.         JSRLIB    EasyRequestArgs
  945.  
  946.         move.l    d0,-(sp)
  947.         bsr    EmulToFront
  948.         move.l    (sp)+,d0
  949.  
  950.         movem.l    (sp)+,a2-a6
  951.         clr.w    DontPause        ;Darf wieder angehalten werden
  952.  
  953.         tst.l    d0
  954.         beq    1$
  955.  
  956.         bsr    Reset6526    ;Reset
  957.         bsr    Reset6581
  958.         moveq    #0,d0        ;MSWs von d0 und d1
  959.         moveq    #0,d1        ; müssen Null sein
  960.         bra    HandleRESET
  961.  
  962. 1$        moveq    #0,d0        ;Weiter
  963.         moveq    #0,d1
  964.         Next    0
  965.  
  966.  
  967. **
  968. ** Speicherzugriff Lesen
  969. ** In a1 steht die Rücksprungadresse
  970. **
  971.  
  972. ; Lesen aus dem RAM
  973. ReadByteRAM    move.b    (RAMPTR,d0.l),d0
  974.         jmp    (a1)
  975.  
  976. ; Lesen aus dem Basic-ROM
  977. ReadByteBasic    and.w    #$1fff,d0
  978.         move.b    ([TheBasic,pc],d0.w),d0
  979.         jmp    (a1)
  980.  
  981. ; Lesen aus einem VIC-Register
  982. ReadByteVIC    and.w    #$3f,d0
  983.         bsr    ReadFrom6569
  984.         jmp    (a1)
  985.  
  986. ; Lesen aus einem SID-Register
  987. ReadByteSID    and.w    #$1f,d0
  988.         bsr    ReadFrom6581
  989.         jmp    (a1)
  990.  
  991. ; Lesen aus dem Farb-RAM
  992. ReadByteColor    and.w    #$03ff,d0
  993.         move.b    ([TheColor,pc],d0.w),d0
  994.         and.b    #$0f,d0
  995.         move.b    $dff007,d1    ;Oberes Nibble ist Zufallswert
  996.         lsl.b    #4,d1        ;Ist so zufälliger
  997.         and.b    #$f0,d1
  998.         or.b    d1,d0
  999.         jmp    (a1)
  1000.  
  1001. ; Lesen aus einem CIA 1-Register
  1002. ReadByteCIA1    and.w    #$0f,d0
  1003.         bsr    ReadFrom6526A
  1004.         jmp    (a1)
  1005.  
  1006. ; Lesen aus einem CIA 2-Register
  1007. ReadByteCIA2    and.w    #$0f,d0
  1008.         bsr    ReadFrom6526B
  1009.         jmp    (a1)
  1010.  
  1011. ; Lesen einer offenen Adresse
  1012. ReadByteUndef    cmp.l    #$dfa0,d0
  1013.         bhs    1$
  1014.         move.b    $dff007,d0    ;Zufallswert
  1015.         jmp    (a1)
  1016.  
  1017. ; $dfa0-$dfff: Emulator-Identifikation
  1018. 1$        cmp.w    #$dfff,d0    ;$dfff liest abwechselnd $55/$aa
  1019.         bne    2$
  1020.         move.b    DFFFByte,d0
  1021.         not.b    DFFFByte
  1022.         jmp    (a1)        
  1023.  
  1024. 2$        cmp.w    #$dffe,d0    ;$dffe liest "F" (Frodo-Kennung)
  1025.         bne    3$
  1026.         moveq    #'F',d0
  1027.         jmp    (a1)
  1028.  
  1029. 3$        cmp.w    #$dffd,d0    ;$dffd: Version
  1030.         bne    4$
  1031.         move.b    #VERSION,d0
  1032.         jmp    (a1)
  1033.  
  1034. 4$        cmp.w    #$dffc,d0    ;$dffc: Revision
  1035.         bne    5$
  1036.         move.b    #REVISION,d0
  1037.         jmp    (a1)
  1038.  
  1039. 5$        sub.w    #$dfa0,d0    ;$dfa0-$dffb: ID-String
  1040.         move.b    IDString(pc,d0.w),d0
  1041.         jmp    (a1)
  1042.  
  1043. ; Lesen aus dem Kernal-ROM
  1044. ReadByteKernal    and.w    #$1fff,d0
  1045.         move.b    ([TheKernal,pc],d0.w),d0
  1046.         jmp    (a1)
  1047.  
  1048. ; Lesen aus dem Char-ROM
  1049. ReadByteChar    and.w    #$0fff,d0
  1050.         move.b    ([TheChar,pc],d0.w),d0
  1051.         jmp    (a1)
  1052.  
  1053.  
  1054. **
  1055. ** Speicherzugriff Schreiben
  1056. ** In a1 steht die 16-Bit-Adresse
  1057. **
  1058.  
  1059. ; Schreiben in Seite 0
  1060. WriteBytePage0    move.l    a1,d0
  1061.         move.b    d1,(RAMPTR,d0.w)
  1062.         cmp.b    #2,d0
  1063.         bhs    1$
  1064.         NewConfig
  1065. 1$        rts
  1066.  
  1067. ; Schreiben ins RAM
  1068. WriteByteRAM    move.b    d1,(RAMPTR,a1.l)
  1069.         rts
  1070.  
  1071. ; Schreiben in ein VIC-Register
  1072. WriteByteVIC    move.l    a1,d0
  1073.         and.w    #$3f,d0
  1074.         bra    WriteTo6569
  1075.  
  1076. ; Schreiben in ein SID-Register
  1077. WriteByteSID    move.l    a1,d0
  1078.         and.w    #$1f,d0
  1079.         bra    WriteTo6581
  1080.  
  1081. ; Schreiben ins Farb-RAM
  1082. WriteByteColor    move.l    a1,d0
  1083.         and.w    #$03ff,d0
  1084.         move.b    d1,([TheColor],d0.w)
  1085.         rts
  1086.  
  1087. ; Schreiben in ein CIA 1-Register
  1088. WriteByteCIA1    move.l    a1,d0
  1089.         and.w    #$0f,d0
  1090.         bra    WriteTo6526A
  1091.  
  1092. ; Schreiben in ein CIA 2-Register
  1093. WriteByteCIA2    move.l    a1,d0
  1094.         and.w    #$0f,d0
  1095.         bra    WriteTo6526B
  1096.  
  1097. ; Schreiben an einer offenen Adresse
  1098. WriteByteUndef    move.l    a1,d0
  1099.         rts
  1100.  
  1101.  
  1102. **
  1103. ** Sprungbefehle
  1104. **
  1105.  
  1106. ; Sprung ins RAM
  1107. JumpToRAM    lea    (RAMPTR,d0.l),RPC
  1108.         rts
  1109.  
  1110. ; Sprung ins Basic-ROM
  1111. JumpToBasic    move.l    TheBasic(pc),RPC
  1112.         and.w    #$1fff,d0
  1113.         add.l    d0,RPC
  1114.         rts
  1115.  
  1116. ; Sprung ins Kernal-ROM
  1117. JumpToKernal    move.l    TheKernal(pc),RPC
  1118.         and.w    #$1fff,d0
  1119.         add.l    d0,RPC
  1120.         rts
  1121.  
  1122. ; Sprung ins Char-ROM (warum sollte jemand sowas tun? Aber egal.)
  1123. JumpToChar    move.l    TheChar(pc),RPC
  1124.         and.w    #$0fff,d0
  1125.         add.l    d0,RPC
  1126.         rts
  1127.  
  1128. ; Sprung in den I/O-Bereich (in VIC-Register wird ab und zu gerne gesprungen,
  1129. ;  $de00 und das Farb-RAM sind auch sehr beliebt)
  1130. JumpToIO    move.w    #-1,DontPause        ;Nicht hier anhalten
  1131.         movem.l    a2-a6,-(sp)
  1132.  
  1133.         move.w    d0,RequestStream    ;PC anzeigen
  1134.  
  1135.         bsr    AmigaToFront
  1136.  
  1137.         move.l    _IntuitionBase,a6
  1138.         sub.l    a0,a0
  1139.         lea    JumpToIOReq,a1
  1140.         move.l    a0,a2
  1141.         lea    RequestStream,a3
  1142.         JSRLIB    EasyRequestArgs
  1143.  
  1144.         bsr    EmulToFront
  1145.  
  1146.         movem.l    (sp)+,a2-a6
  1147.         clr.w    DontPause        ;Darf wieder angehalten werden
  1148.  
  1149.         bsr    Reset6526
  1150.         bsr    Reset6581
  1151.         moveq    #0,d0            ;MSWs von d0 und d1
  1152.         moveq    #0,d1            ; müssen Null sein
  1153.  
  1154.         addq.l    #4,sp            ;Rücksprungadresse löschen
  1155.         bra    HandleRESET
  1156.  
  1157.  
  1158. **
  1159. ** Opcode-Routinen
  1160. **
  1161.  
  1162. *
  1163. * Interrupts handhaben
  1164. *
  1165.  
  1166. ; Art des Interrupt feststellen (Priorität)
  1167. HandleInt    tst.b    IntIsRESET(pc)
  1168.         bne    HandleRESET
  1169.         tst.b    IntIsNMI(pc)
  1170.         bne    HandleNMI
  1171.         tst.b    IntIsVICIRQ(pc)
  1172.         bne    HandleVICIRQ
  1173.         tst.b    IntIsCIAIRQ(pc)
  1174.         bne    HandleCIAIRQ
  1175.  
  1176. ; Kein Interrupt, nächsten Befehl ausführen
  1177. HandleIntDone    Next    0
  1178.  
  1179. ; IRQ: Interrupt-Bit testen, nach ($fffe) springen
  1180. HandleVICIRQ    btst    #InterruptBit,RP
  1181.         beq    HandleIRQ
  1182.         Next    0
  1183.  
  1184. HandleCIAIRQ    btst    #InterruptBit,RP
  1185.         beq    HandleIRQ
  1186.         Next    0
  1187.  
  1188. HandleIRQ    PushPC
  1189.         PushP
  1190.  
  1191.         or.w    #InterruptMask,RP
  1192.         move.w    #$fffe,d0    ;IRQ-Vektor
  1193.         ReadWord
  1194.         Jump
  1195.         Next    7
  1196.  
  1197. ; NMI: Nach ($fffa) springen
  1198. HandleNMI    clr.b    IntIsNMI    ;Simuliert einen flankengetriggerten Eingang
  1199.  
  1200.         PushPC
  1201.         PushP
  1202.  
  1203.         or.w    #InterruptMask,RP
  1204.         move.w    #$fffa,d0    ;NMI-Vektor
  1205.         ReadWord
  1206.         Jump
  1207.         Next    7
  1208.  
  1209. ; RESET: Emulator beenden oder nach ($fffc) springen
  1210. HandleRESET    tst.b    RESETIsEXIT(pc)    ;Beenden?
  1211.         bne    HandleEXIT
  1212.  
  1213.         clr.l    Interrupt    ;Nein, RESET
  1214.  
  1215.         cmp.l    #$c3c2cd38,$8004(RAMPTR)
  1216.         bne    1$
  1217.         cmp.b    #$30,$8008(RAMPTR)
  1218.         bne    1$
  1219.         clr.b    $8004(RAMPTR)    ;CBM80 löschen, wenn vorhanden
  1220.  
  1221. 1$        move.w    #$ff07,(RAMPTR)    ;Speicherkonfiguration initialisieren
  1222.         NewConfig
  1223.  
  1224.         move.w    #$fffc,d0    ;RESET-Vektor
  1225.         ReadWord
  1226.         Jump
  1227.         Next    0
  1228.  
  1229. ; EXIT: Signal an den Emulator schicken
  1230. HandleEXIT    bsr    Exit6569        ;6569 aufräumen
  1231.  
  1232.         move.l    _SysBase,a6
  1233.         JSRLIB    Forbid
  1234.         move.l    MainTask,a1
  1235.         move.l    ReadySet,d0
  1236.         JSRLIB    Signal
  1237.         moveq    #0,d0
  1238.         rts
  1239.  
  1240. *
  1241. * Periodic: Wird über den Opcode-Fetch aufgerufen,
  1242. *  wenn der Zyklenzähler unterläuft
  1243. *
  1244.  
  1245. ; VIC und CIA aufrufen
  1246. Periodic    movem.w    d2-d7,-(sp)    ;Gerade Anzahl von Registern
  1247.         movem.l    a2-a3/a5,-(sp)
  1248.         bra    Periodic6569    ;Beide springen direkt zurück
  1249. Peri6569Cont    bra    Periodic6526
  1250. Peri6526Cont    movem.l    (sp)+,a2-a3/a5
  1251.         movem.w    (sp)+,d2-d7
  1252.         move.l    TheRAM,RAMPTR    ;a4
  1253.         moveq    #0,d0
  1254.         moveq    #0,d1
  1255.  
  1256. ; Interrupt aufgetreten?
  1257.         tst.l    Interrupt(pc)
  1258.         bne    HandleInt
  1259.  
  1260. ; Nein, Nächsten Befehl ausführen
  1261.         Next    0
  1262.  
  1263. *
  1264. * Opcodes
  1265. *
  1266.  
  1267. ; Laden
  1268. LoadA        MACRO    ;Quelle, Zyklenzahl
  1269.         move.b    \1,RA
  1270.         move    ccr,RCCR
  1271.         Next    \2
  1272.         ENDM
  1273.  
  1274. LoadX        MACRO    ;Quelle, Zyklenzahl
  1275.         move.b    \1,RX
  1276.         move    ccr,RCCR
  1277.         Next    \2
  1278.         ENDM
  1279.  
  1280. LoadY        MACRO    ;Quelle, Zyklenzahl
  1281.         move.b    \1,RY
  1282.         move    ccr,RCCR
  1283.         Next    \2
  1284.         ENDM
  1285.  
  1286. LoadAX        MACRO    ;Quelle, Zyklenzahl
  1287.         move.b    \1,RA
  1288.         move.b    RA,RX
  1289.         move    ccr,RCCR
  1290.         Next    \2
  1291.         ENDM
  1292.  
  1293. LDAImm        LoadA    (RPC)+,2
  1294.  
  1295. LDAZero        ReadAdrZero
  1296.         LoadA    (RAMPTR,d0.w),3
  1297.  
  1298. LDAZeroX    ReadAdrZeroX
  1299.         LoadA    (RAMPTR,d0.w),4
  1300.  
  1301. LDAAbs        ReadByteAbs
  1302.         LoadA    d0,4
  1303.  
  1304. LDAAbsX        ReadByteAbsX
  1305.         LoadA    d0,4
  1306.  
  1307. LDAAbsY        ReadByteAbsY
  1308.         LoadA    d0,4
  1309.  
  1310. LDAIndX        ReadByteIndX
  1311.         LoadA    d0,6
  1312.  
  1313. LDAIndY        ReadByteIndY
  1314.         LoadA    d0,5
  1315.  
  1316. LDXImm        LoadX    (RPC)+,2
  1317.  
  1318. LDXZero        ReadAdrZero
  1319.         LoadX    (RAMPTR,d0.w),3
  1320.  
  1321. LDXZeroY    ReadAdrZeroY
  1322.         LoadX    (RAMPTR,d0.w),4
  1323.  
  1324. LDXAbs        ReadByteAbs
  1325.         LoadX    d0,4
  1326.  
  1327. LDXAbsY        ReadByteAbsY
  1328.         LoadX    d0,4
  1329.  
  1330. LDYImm        LoadY    (RPC)+,2
  1331.  
  1332. LDYZero        ReadAdrZero
  1333.         LoadY    (RAMPTR,d0.w),3
  1334.  
  1335. LDYZeroX    ReadAdrZeroX
  1336.         LoadY    (RAMPTR,d0.w),4
  1337.  
  1338. LDYAbs        ReadByteAbs
  1339.         LoadY    d0,4
  1340.  
  1341. LDYAbsX        ReadByteAbsX
  1342.         LoadY    d0,4
  1343.  
  1344. LAXZero        ReadAdrZero
  1345.         LoadAX    (RAMPTR,d0.w),3
  1346.  
  1347. LAXZeroY    ReadAdrZeroY
  1348.         LoadAX    (RAMPTR,d0.w),4
  1349.  
  1350. LAXAbs        ReadByteAbs
  1351.         LoadAX    d0,4
  1352.  
  1353. LAXAbsY        ReadByteAbsY
  1354.         LoadAX    d0,4
  1355.  
  1356. LAXIndX        ReadByteIndX
  1357.         LoadAX    d0,6
  1358.  
  1359. LAXIndY        ReadByteIndY
  1360.         LoadAX    d0,5
  1361.  
  1362. ; Speichern
  1363. StoreA        MACRO    ;Zyklenzahl
  1364.         move.b    RA,d1
  1365.         WriteByte
  1366.         Next    \1
  1367.         ENDM
  1368.  
  1369. StoreAX        MACRO    ;Zyklenzahl
  1370.         move.b    RA,d1
  1371.         and.b    RX,d1
  1372.         WriteByte
  1373.         Next    \1
  1374.         ENDM
  1375.  
  1376. STAZero        ReadAdrZero
  1377.         WriteZeroNext    RA,3
  1378.  
  1379. STAZeroX    ReadAdrZeroX
  1380.         WriteZeroNext    RA,4
  1381.  
  1382. STAAbs        ReadAdrAbs
  1383.         StoreA    4
  1384.  
  1385. STAAbsX        ReadAdrAbsX
  1386.         StoreA    5
  1387.  
  1388. STAAbsY        ReadAdrAbsY
  1389.         StoreA    5
  1390.  
  1391. STAIndX        ReadAdrIndX
  1392.         StoreA    6
  1393.  
  1394. STAIndY        ReadAdrIndY
  1395.         StoreA    6
  1396.  
  1397. STXZero        ReadAdrZero
  1398.         WriteZeroNext    RX,3
  1399.  
  1400. STXZeroY    ReadAdrZeroY
  1401.         WriteZeroNext    RX,4
  1402.  
  1403. STXAbs        ReadAdrAbs
  1404.         move.b    RX,d1
  1405.         WriteByte
  1406.         Next    4
  1407.  
  1408. STYZero        ReadAdrZero
  1409.         WriteZeroNext    RY,3
  1410.  
  1411. STYZeroX    ReadAdrZeroX
  1412.         WriteZeroNext    RY,4
  1413.  
  1414. STYAbs        ReadAdrAbs
  1415.         move.b    RY,d1
  1416.         WriteByte
  1417.         Next    4
  1418.  
  1419. SAXZero        ReadAdrZero
  1420.         StoreAX    3
  1421.  
  1422. SAXZeroY    ReadAdrZeroY
  1423.         StoreAX    4
  1424.  
  1425. SAXAbs        ReadAdrAbs
  1426.         StoreAX    4
  1427.  
  1428. SAXIndX        ReadAdrIndX
  1429.         StoreAX    6
  1430.  
  1431. ; Datentransport zwischen Registern
  1432. TAX        move.b    RA,RX
  1433.         move    ccr,RCCR
  1434.         Next    2
  1435.  
  1436. TAY        move.b    RA,RY
  1437.         move    ccr,RCCR
  1438.         Next    2
  1439.  
  1440. TXA        move.b    RX,RA
  1441.         move    ccr,RCCR
  1442.         Next    2
  1443.  
  1444. TYA        move.b    RY,RA
  1445.         move    ccr,RCCR
  1446.         Next    2
  1447.  
  1448. TXS        move.b    RX,RS
  1449.         Next    2
  1450.  
  1451. TSX        move.b    RS,RX
  1452.         move    ccr,RCCR
  1453.         Next    2
  1454.  
  1455. ; Stack
  1456. PHA        PushByte RA
  1457.         Next    3
  1458.  
  1459. PLA        PopByte    RA
  1460.         move    ccr,RCCR
  1461.         Next    4
  1462.  
  1463. PHP        or.w    #BreakMask,RP    ;Prozessorfehler: Break-Flag
  1464.         PushP            ; wird auf dem Stack gesetzt
  1465.         and.w    #~BreakMask,RP
  1466.         Next    3
  1467.  
  1468. PLP        PopP
  1469.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  1470.         beq    1$
  1471.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  1472.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  1473. 1$        Next    4
  1474.  
  1475. ; Vergleiche
  1476. CompareA    MACRO    ;Quelle, Zyklenzahl
  1477.         cmp.b    \1,RA
  1478.         move    ccr,RCCR
  1479.         move.b    RCCR,RP        ;Carry holen und invertieren
  1480.         not.b    RP
  1481.         Next    \2
  1482.         ENDM
  1483.  
  1484. CMPImm        CompareA    (RPC)+,2
  1485.  
  1486. CMPZero        ReadAdrZero
  1487.         CompareA    (RAMPTR,d0.w),3
  1488.  
  1489. CMPZeroX    ReadAdrZeroX
  1490.         CompareA    (RAMPTR,d0.w),4
  1491.  
  1492. CMPAbs        ReadByteAbs
  1493.         CompareA    d0,4
  1494.  
  1495. CMPAbsX        ReadByteAbsX
  1496.         CompareA    d0,4
  1497.  
  1498. CMPAbsY        ReadByteAbsY
  1499.         CompareA    d0,4
  1500.  
  1501. CMPIndX        ReadByteIndX
  1502.         CompareA    d0,6
  1503.  
  1504. CMPIndY        ReadByteIndY
  1505.         CompareA    d0,5
  1506.  
  1507. CPXImm        cmp.b    (RPC)+,RX
  1508.         move    ccr,RCCR
  1509.         move.b    RCCR,RP        ;Carry holen und invertieren
  1510.         not.b    RP
  1511.         Next    2
  1512.  
  1513. CPXZero        ReadAdrZero
  1514.         cmp.b    (RAMPTR,d0.w),RX
  1515.         move    ccr,RCCR
  1516.         move.b    RCCR,RP        ;Carry holen und invertieren
  1517.         not.b    RP
  1518.         Next    3
  1519.  
  1520. CPXAbs        ReadByteAbs
  1521.         cmp.b    d0,RX
  1522.         move    ccr,RCCR
  1523.         move.b    RCCR,RP        ;Carry holen und invertieren
  1524.         not.b    RP
  1525.         Next    4
  1526.  
  1527. CPYImm        cmp.b    (RPC)+,RY
  1528.         move    ccr,RCCR
  1529.         move.b    RCCR,RP        ;Carry holen und invertieren
  1530.         not.b    RP
  1531.         Next    2
  1532.  
  1533. CPYZero        ReadAdrZero
  1534.         cmp.b    (RAMPTR,d0.w),RY
  1535.         move    ccr,RCCR
  1536.         move.b    RCCR,RP        ;Carry holen und invertieren
  1537.         not.b    RP
  1538.         Next    3
  1539.  
  1540. CPYAbs        ReadByteAbs
  1541.         cmp.b    d0,RY
  1542.         move    ccr,RCCR
  1543.         move.b    RCCR,RP        ;Carry holen und invertieren
  1544.         not.b    RP
  1545.         Next    4
  1546.  
  1547. ; Arithmetische Operationen
  1548. AdcA        MACRO    ;Zyklenzahl
  1549.         lsr.b    #1,RP        ;Carry -> X
  1550.         btst    #DecimalBit,RP
  1551.         bne    \@1$
  1552.         addx.b    d0,RA
  1553.         move    ccr,RCCR
  1554.         bvc    \@2$        ;Overflow holen
  1555.         or.w    #OverflowMask,RP
  1556.         move.b    RCCR,RP        ;Carry holen
  1557.         Next    \1
  1558. \@2$        and.w    #~OverflowMask,RP
  1559.         move.b    RCCR,RP        ;Carry holen
  1560.         Next    \1
  1561. \@1$        moveq    #0,d1        ;V und C löschen
  1562.         abcd.b    d0,RA
  1563.         move    ccr,RCCR
  1564.         bvc    \@2$        ;Overflow holen
  1565.         or.w    #OverflowMask,RP
  1566.         move.b    RCCR,RP        ;Carry holen
  1567.         Next    \1
  1568.         ENDM
  1569.  
  1570. ADCImm        move.b    (RPC)+,d0
  1571.         AdcA    2
  1572.  
  1573. ADCZero        ReadByteZero    d0
  1574.         AdcA    3
  1575.  
  1576. ADCZeroX    ReadByteZeroX    d0
  1577.         AdcA    4
  1578.  
  1579. ADCAbs        ReadByteAbs
  1580.         AdcA    4
  1581.  
  1582. ADCAbsX        ReadByteAbsX
  1583.         AdcA    4
  1584.  
  1585. ADCAbsY        ReadByteAbsY
  1586.         AdcA    4
  1587.  
  1588. ADCIndX        ReadByteIndX
  1589.         AdcA    6
  1590.  
  1591. ADCIndY        ReadByteIndY
  1592.         AdcA    5
  1593.  
  1594. SbcA        MACRO    ;Zyklenzahl
  1595.         not.b    RP
  1596.         lsr.b    #1,RP        ;Carry invertieren und nach X
  1597.         btst    #DecimalBit,RP
  1598.         bne    \@1$
  1599.         subx.b    d0,RA
  1600.         move    ccr,RCCR
  1601.         bvc    \@2$        ;Overflow holen
  1602.         or.w    #OverflowMask,RP
  1603.         move.b    RCCR,RP        ;Carry holen und invertieren
  1604.         not.b    RP
  1605.         Next    \1
  1606. \@2$        and.w    #~OverflowMask,RP
  1607.         move.b    RCCR,RP        ;Carry holen und invertieren
  1608.         not.b    RP
  1609.         Next    \1
  1610. \@1$        moveq    #0,d1        ;V und C löschen
  1611.         sbcd.b    d0,RA
  1612.         move    ccr,RCCR
  1613.         bvc    \@2$        ;Overflow holen
  1614.         or.w    #OverflowMask,RP
  1615.         move.b    RCCR,RP        ;Carry holen und invertieren
  1616.         not.b    RP
  1617.         Next    \1
  1618.         ENDM
  1619.  
  1620. SBCImm        move.b    (RPC)+,d0
  1621.         SbcA    2
  1622.  
  1623. SBCZero        ReadByteZero    d0
  1624.         SbcA    3
  1625.  
  1626. SBCZeroX    ReadByteZeroX    d0
  1627.         SbcA    4
  1628.  
  1629. SBCAbs        ReadByteAbs
  1630.         SbcA    4
  1631.  
  1632. SBCAbsX        ReadByteAbsX
  1633.         SbcA    4
  1634.  
  1635. SBCAbsY        ReadByteAbsY
  1636.         SbcA    4
  1637.  
  1638. SBCIndX        ReadByteIndX
  1639.         SbcA    6
  1640.  
  1641. SBCIndY        ReadByteIndY
  1642.         SbcA    5
  1643.  
  1644. Increment    MACRO    ;Zyklenzahl
  1645.         move.l    d0,-(sp)
  1646.         ReadByte
  1647.         addq.b    #1,d0
  1648.         move    ccr,RCCR
  1649.         move.b    d0,d1
  1650.         move.l    (sp)+,d0
  1651.         WriteByte
  1652.         Next    \1
  1653.         ENDM
  1654.  
  1655. IncrementZero    MACRO    ;Zyklenzahl
  1656.         addq.b    #1,(RAMPTR,d0.w)
  1657.         move    ccr,RCCR
  1658.         cmp.b    #2,d0
  1659.         bhs    \@1$
  1660.         NewConfig
  1661. \@1$        Next    \1
  1662.         ENDM
  1663.  
  1664. INCZero        ReadAdrZero
  1665.         IncrementZero    5
  1666.  
  1667. INCZeroX    ReadAdrZeroX
  1668.         IncrementZero    6
  1669.  
  1670. INCAbs        ReadAdrAbs
  1671.         Increment    6
  1672.  
  1673. INCAbsX        ReadAdrAbsX
  1674.         Increment    7
  1675.  
  1676. Decrement    MACRO    ;Zyklenzahl
  1677.         move.l    d0,-(sp)
  1678.         ReadByte
  1679.         subq.b    #1,d0
  1680.         move    ccr,RCCR
  1681.         move.b    d0,d1
  1682.         move.l    (sp)+,d0
  1683.         WriteByte
  1684.         Next    \1
  1685.         ENDM
  1686.  
  1687. DecrementZero    MACRO    ;Zyklenzahl
  1688.         subq.b    #1,(RAMPTR,d0.w)
  1689.         move    ccr,RCCR
  1690.         cmp.b    #2,d0
  1691.         bhs    \@1$
  1692.         NewConfig
  1693. \@1$        Next    \1
  1694.         ENDM
  1695.  
  1696. DECZero        ReadAdrZero
  1697.         DecrementZero    5
  1698.         
  1699. DECZeroX    ReadAdrZeroX
  1700.         DecrementZero    6
  1701.  
  1702. DECAbs        ReadAdrAbs
  1703.         Decrement    6
  1704.  
  1705. DECAbsX        ReadAdrAbsX
  1706.         Decrement    7
  1707.  
  1708. INX        addq.b    #1,RX
  1709.         move    ccr,RCCR
  1710.         Next    2
  1711.  
  1712. DEX        subq.b    #1,RX
  1713.         move    ccr,RCCR
  1714.         Next    2
  1715.  
  1716. INY        addq.b    #1,RY
  1717.         move    ccr,RCCR
  1718.         Next    2
  1719.  
  1720. DEY        subq.b    #1,RY
  1721.         move    ccr,RCCR
  1722.         Next    2
  1723.  
  1724. ; Logische Operationen
  1725. AndA        MACRO    ;Quelle, Zyklenzahl
  1726.         and.b    \1,RA
  1727.         move    ccr,RCCR
  1728.         Next    \2
  1729.         ENDM
  1730.  
  1731. ANDImm        AndA    (RPC)+,2
  1732.  
  1733. ANDZero        ReadAdrZero
  1734.         AndA    (RAMPTR,d0.w),3
  1735.  
  1736. ANDZeroX    ReadAdrZeroX
  1737.         AndA    (RAMPTR,d0.w),4
  1738.  
  1739. ANDAbs        ReadByteAbs
  1740.         AndA    d0,4
  1741.  
  1742. ANDAbsX        ReadByteAbsX
  1743.         AndA    d0,4
  1744.  
  1745. ANDAbsY        ReadByteAbsY
  1746.         AndA    d0,4
  1747.  
  1748. ANDIndX        ReadByteIndX
  1749.         AndA    d0,6
  1750.  
  1751. ANDIndY        ReadByteIndY
  1752.         AndA    d0,5
  1753.  
  1754. OrA        MACRO    ;Quelle, Zyklenzahl
  1755.         or.b    \1,RA
  1756.         move    ccr,RCCR
  1757.         Next    \2
  1758.         ENDM
  1759.  
  1760. ORAImm        OrA    (RPC)+,2
  1761.  
  1762. ORAZero        ReadAdrZero
  1763.         OrA    (RAMPTR,d0.w),3
  1764.  
  1765. ORAZeroX    ReadAdrZeroX
  1766.         OrA    (RAMPTR,d0.w),4
  1767.  
  1768. ORAAbs        ReadByteAbs
  1769.         OrA    d0,4
  1770.  
  1771. ORAAbsX        ReadByteAbsX
  1772.         OrA    d0,4
  1773.  
  1774. ORAAbsY        ReadByteAbsY
  1775.         OrA    d0,4
  1776.  
  1777. ORAIndX        ReadByteIndX
  1778.         OrA    d0,6
  1779.  
  1780. ORAIndY        ReadByteIndY
  1781.         OrA    d0,5
  1782.  
  1783. EorA        MACRO    ;Zyklenzahl
  1784.         eor.b    d0,RA        ;eor.b (ea),RA geht nicht
  1785.         move    ccr,RCCR    ;(Warum nicht, Motorola ?) :-(
  1786.         Next    \1
  1787.         ENDM
  1788.  
  1789. EORImm        move.b    (RPC)+,d0
  1790.         EorA    2
  1791.  
  1792. EORZero        ReadAdrZero
  1793.         move.b    (RAMPTR,d0.w),d0
  1794.         EorA    3
  1795.  
  1796. EORZeroX    ReadAdrZeroX
  1797.         move.b    (RAMPTR,d0.w),d0
  1798.         EorA    4
  1799.  
  1800. EORAbs        ReadByteAbs
  1801.         EorA    4
  1802.  
  1803. EORAbsX        ReadByteAbsX
  1804.         EorA    4
  1805.  
  1806. EORAbsY        ReadByteAbsY
  1807.         EorA    4
  1808.  
  1809. EORIndX        ReadByteIndX
  1810.         EorA    6
  1811.  
  1812. EORIndY        ReadByteIndY
  1813.         EorA    5
  1814.  
  1815. BitTest        MACRO    ;Zyklenzahl
  1816.         tst.b    d0        ;N holen
  1817.         move    ccr,RCCR
  1818.         and.w    #$1cff,RP    ;B,D,I und C behalten
  1819.  
  1820.         btst    #6,d0        ;Bit 6 -> V
  1821.         beq    \@1$
  1822.         or.w    #OverflowMask,RP
  1823.  
  1824. \@1$        and.b    RA,d0        ;A AND M -> Z
  1825.         beq    \@2$
  1826.         and.b    #$fb,RCCR
  1827.         Next    \1
  1828. \@2$        or.b    #$04,RCCR
  1829.         Next    \1
  1830.         ENDM
  1831.  
  1832. BITZero        ReadByteZero    d0
  1833.         BitTest    3
  1834.  
  1835. BITAbs        ReadByteAbs
  1836.         BitTest    4
  1837.  
  1838. ; Verschiebungen
  1839. ShiftLeft    MACRO    ;Zyklenzahl
  1840.         move.l    d0,-(sp)
  1841.         ReadByte
  1842.         add.b    d0,d0
  1843.         move    ccr,RCCR
  1844.         move.b    RCCR,RP        ;Carry holen
  1845.         move.b    d0,d1
  1846.         move.l    (sp)+,d0
  1847.         WriteByte
  1848.         Next    \1
  1849.         ENDM
  1850.  
  1851. ShiftLeftZero    MACRO    ;Zyklenzahl
  1852.         lea    (RAMPTR,d0.w),a0
  1853.         move.b    (a0),d1
  1854.         add.b    d1,d1
  1855.         move    ccr,RCCR
  1856.         move.b    RCCR,RP        ;Carry holen
  1857.         move.b    d1,(a0)
  1858.         cmp.b    #2,d0
  1859.         bhs    \@1$
  1860.         NewConfig
  1861. \@1$        Next    \1
  1862.         ENDM
  1863.  
  1864. ASLA        add.b    RA,RA
  1865.         move    ccr,RCCR
  1866.         move.b    RCCR,RP        ;Carry holen
  1867.         Next    2
  1868.  
  1869. ASLZero        ReadAdrZero
  1870.         ShiftLeftZero    5
  1871.  
  1872. ASLZeroX    ReadAdrZeroX
  1873.         ShiftLeftZero    6
  1874.  
  1875. ASLAbs        ReadAdrAbs
  1876.         ShiftLeft    6
  1877.  
  1878. ASLAbsX        ReadAdrAbsX
  1879.         ShiftLeft    7
  1880.  
  1881. ShiftRight    MACRO    ;Zyklenzahl
  1882.         move.l    d0,-(sp)
  1883.         ReadByte
  1884.         lsr.b    #1,d0
  1885.         move    ccr,RCCR
  1886.         move.b    RCCR,RP        ;Carry holen
  1887.         move.b    d0,d1
  1888.         move.l    (sp)+,d0
  1889.         WriteByte
  1890.         Next    \1
  1891.         ENDM
  1892.  
  1893. ShiftRightZero    MACRO    ;Zyklenzahl
  1894.         lea    (RAMPTR,d0.w),a0
  1895.         move.b    (a0),d1
  1896.         lsr.b    #1,d1
  1897.         move    ccr,RCCR
  1898.         move.b    RCCR,RP        ;Carry holen
  1899.         move.b    d1,(a0)
  1900.         cmp.b    #2,d0
  1901.         bhs    \@1$
  1902.         NewConfig
  1903. \@1$        Next    \1
  1904.         ENDM
  1905.  
  1906. LSRA        lsr.b    #1,RA
  1907.         move    ccr,RCCR
  1908.         move.b    RCCR,RP        ;Carry holen
  1909.         Next    2
  1910.  
  1911. LSRZero        ReadAdrZero
  1912.         ShiftRightZero    5
  1913.  
  1914. LSRZeroX    ReadAdrZeroX
  1915.         ShiftRightZero    6
  1916.  
  1917. LSRAbs        ReadAdrAbs
  1918.         ShiftRight    6
  1919.  
  1920. LSRAbsX        ReadAdrAbsX
  1921.         ShiftRight    7
  1922.  
  1923. RotateLeft    MACRO    ;Zyklenzahl
  1924.         move.l    d0,-(sp)
  1925.         ReadByte
  1926.         lsr.b    #1,RP        ;Carry -> X
  1927.         roxl.b    #1,d0
  1928.         move    ccr,RCCR
  1929.         move.b    RCCR,RP        ;Carry holen
  1930.         move.b    d0,d1
  1931.         move.l    (sp)+,d0
  1932.         WriteByte
  1933.         Next    \1
  1934.         ENDM
  1935.  
  1936. RotateLeftZero    MACRO    ;Zyklenzahl
  1937.         lea    (RAMPTR,d0.w),a0
  1938.         move.b    (a0),d1
  1939.         lsr.b    #1,RP        ;Carry -> X
  1940.         roxl.b    #1,d1
  1941.         move    ccr,RCCR
  1942.         move.b    RCCR,RP        ;Carry holen
  1943.         move.b    d1,(a0)
  1944.         cmp.b    #2,d0
  1945.         bhs    \@1$
  1946.         NewConfig
  1947. \@1$        Next    \1
  1948.         ENDM
  1949.  
  1950. ROLA        lsr.b    #1,RP        ;Carry -> X
  1951.         roxl.b    #1,RA
  1952.         move    ccr,RCCR
  1953.         move.b    RCCR,RP        ;Carry holen
  1954.         Next    2
  1955.  
  1956. ROLZero        ReadAdrZero
  1957.         RotateLeftZero    5
  1958.  
  1959. ROLZeroX    ReadAdrZeroX
  1960.         RotateLeftZero    6
  1961.  
  1962. ROLAbs        ReadAdrAbs
  1963.         RotateLeft    6
  1964.  
  1965. ROLAbsX        ReadAdrAbsX
  1966.         RotateLeft    7
  1967.  
  1968. RotateRight    MACRO    ;Zyklenzahl
  1969.         move.l    d0,-(sp)
  1970.         ReadByte
  1971.         lsr.b    #1,RP        ;Carry -> X
  1972.         roxr.b    #1,d0
  1973.         move    ccr,RCCR
  1974.         move.b    RCCR,RP        ;Carry holen
  1975.         move.b    d0,d1
  1976.         move.l    (sp)+,d0
  1977.         WriteByte
  1978.         Next    \1
  1979.         ENDM
  1980.  
  1981. RotateRightZero    MACRO    ;Zyklenzahl
  1982.         lea    (RAMPTR,d0.w),a0
  1983.         move.b    (a0),d1
  1984.         lsr.b    #1,RP        ;Carry -> X
  1985.         roxr.b    #1,d1
  1986.         move    ccr,RCCR
  1987.         move.b    RCCR,RP        ;Carry holen
  1988.         move.b    d1,(a0)
  1989.         cmp.b    #2,d0
  1990.         bhs    \@1$
  1991.         NewConfig
  1992. \@1$        Next    \1
  1993.         ENDM
  1994.  
  1995. RORA        lsr.b    #1,RP        ;Carry -> X
  1996.         roxr.b    #1,RA
  1997.         move    ccr,RCCR
  1998.         move.b    RCCR,RP        ;Carry holen
  1999.         Next    2
  2000.  
  2001. RORZero        ReadAdrZero
  2002.         RotateRightZero    5
  2003.  
  2004. RORZeroX    ReadAdrZeroX
  2005.         RotateRightZero    6
  2006.  
  2007. RORAbs        ReadAdrAbs
  2008.         RotateRight    6
  2009.  
  2010. RORAbsX        ReadAdrAbsX
  2011.         RotateRight    7
  2012.  
  2013. ; Sprünge/Verzweigungen
  2014. JMPAbs        ReadAdrAbs
  2015.         Jump
  2016.         Next    3
  2017.  
  2018. JMPInd        ReadAdrInd
  2019.         Jump
  2020.         Next    5
  2021.  
  2022. JSRAbs        PushPCPlus1
  2023.         ReadAdrAbs
  2024.         Jump
  2025.         Next    6
  2026.  
  2027. RTSImpl        PopByte    d1        ;LSB
  2028.         PopByte    d0        ;MSB
  2029.         lsl.w    #8,d0        ;schieben
  2030.         move.b    d1,d0        ;LSB dazunehmen
  2031.         addq.w    #1,d0        ;Adresse um eins erhöhen
  2032.         Jump
  2033.         Next    6
  2034.  
  2035. RTIImpl        PopP
  2036.         PopByte    d1        ;LSB
  2037.         PopByte    d0        ;MSB
  2038.         lsl.w    #8,d0        ;schieben
  2039.         move.b    d1,d0        ;LSB dazunehmen
  2040.         Jump
  2041.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  2042.         beq    1$
  2043.         btst    #InterruptBit,RP ;Ja, I-Flag gelöscht?
  2044.         beq    HandleIRQ    ;Ja, Interrupt auslösen
  2045. 1$        Next    6
  2046.  
  2047. BRK        PushPC
  2048.         or.w    #BreakMask,RP    ;Break-Flag nur auf dem Stapel setzen
  2049.         PushP
  2050.         and.w    #~BreakMask,RP
  2051.         or.w    #InterruptMask,RP
  2052.         move.w    #$fffe,d0    ;IRQ-Vektor
  2053.         ReadWord
  2054.         Jump
  2055.         Next    7
  2056.  
  2057. Branch        MACRO
  2058.         ReadByteRel
  2059.         add.w    d0,RPC        ;!! Kein Wraparound
  2060.         Next    3
  2061.         ENDM
  2062.  
  2063. BVCRel        btst    #OverflowBit,RP
  2064.         bne    BVCNot
  2065.         Branch
  2066. BVCNot        addq.l    #1,RPC
  2067.         Next    2
  2068.  
  2069. BVSRel        btst    #OverflowBit,RP
  2070.         beq    BVSNot
  2071.         Branch
  2072. BVSNot        addq.l    #1,RPC
  2073.         Next    2
  2074.  
  2075. BEQRel        btst    #2,RCCR
  2076.         beq    BEQNot
  2077.         Branch
  2078. BEQNot        addq.l    #1,RPC
  2079.         Next    2
  2080.  
  2081. BNERel        btst    #2,RCCR
  2082.         bne    BNENot
  2083.         Branch
  2084. BNENot        addq.l    #1,RPC
  2085.         Next    2
  2086.  
  2087. BPLRel        btst    #3,RCCR
  2088.         bne    BPLNot
  2089.         Branch
  2090. BPLNot        addq.l    #1,RPC
  2091.         Next    2
  2092.  
  2093. BMIRel        btst    #3,RCCR
  2094.         beq    BMINot
  2095.         Branch
  2096. BMINot        addq.l    #1,RPC
  2097.         Next    2
  2098.  
  2099. BCCRel        btst    #CarryBit,RP
  2100.         bne    BCCNot
  2101.         Branch
  2102. BCCNot        addq.l    #1,RPC
  2103.         Next    2
  2104.  
  2105. BCSRel        btst    #CarryBit,RP
  2106.         beq    BCSNot
  2107.         Branch
  2108. BCSNot        addq.l    #1,RPC
  2109.         Next    2
  2110.  
  2111. ; Statusregister
  2112. SEI        or.w    #InterruptMask,RP
  2113.         Next    2
  2114.  
  2115. CLI        and.w    #~InterruptMask,RP
  2116.         tst.w    IntIsIRQ(pc)    ;Steht ein IRQ an?
  2117.         bne    HandleIRQ    ;Ja, auslösen
  2118.         Next    2
  2119.  
  2120. CLC        clr.b    RP
  2121.         Next    2
  2122.  
  2123. SEC        st.b    RP
  2124.         Next    2
  2125.  
  2126. SED        or.w    #DecimalMask,RP
  2127.         Next    2
  2128.  
  2129. CLD        and.w    #~DecimalMask,RP
  2130.         Next    2
  2131.  
  2132. CLV        and.w    #~OverflowMask,RP
  2133.         Next    2
  2134.  
  2135. ; Leerbefehle
  2136. NOPImpl        Next    2
  2137.  
  2138. NOPZero        addq.w    #1,RPC
  2139.         Next    3
  2140.  
  2141. NOPZeroX    addq.w    #1,RPC
  2142.         Next    4
  2143.  
  2144. NOPAbsX
  2145. NOPAbs        addq.w    #2,RPC
  2146.         Next    4
  2147.  
  2148. ; ASL/ORA-Gruppe
  2149. ShLeftOr    MACRO    ;Zyklenzahl
  2150.         move.l    d0,-(sp)
  2151.         ReadByte
  2152.         add.b    d0,d0
  2153.         move    ccr,RCCR
  2154.         move.b    RCCR,RP        ;Carry holen
  2155.         or.b    d0,RA
  2156.         move.b    d0,d1
  2157.         move.l    (sp)+,d0
  2158.         WriteByte
  2159.         Next    \1
  2160.         ENDM
  2161.  
  2162. ShLeftOrZero    MACRO    ;Zyklenzahl
  2163.         lea    (RAMPTR,d0.w),a0
  2164.         move.b    (a0),d1
  2165.         add.b    d1,d1
  2166.         move    ccr,RCCR
  2167.         move.b    RCCR,RP        ;Carry holen
  2168.         or.b    d1,RA
  2169.         move.b    d1,(a0)
  2170.         cmp.b    #2,d0
  2171.         bhs    \@1$
  2172.         NewConfig
  2173. \@1$        Next    \1
  2174.         ENDM
  2175.  
  2176. SLOZero        ReadAdrZero
  2177.         ShLeftOrZero    5
  2178.  
  2179. SLOZeroX    ReadAdrZeroX
  2180.         ShLeftOrZero    6
  2181.  
  2182. SLOAbs        ReadAdrAbs
  2183.         ShLeftOr    6
  2184.  
  2185. SLOAbsX        ReadAdrAbsX
  2186.         ShLeftOr    7
  2187.  
  2188. SLOAbsY        ReadAdrAbsY
  2189.         ShLeftOr    7
  2190.  
  2191. SLOIndX        ReadAdrIndX
  2192.         ShLeftOr    8
  2193.  
  2194. SLOIndY        ReadAdrIndY
  2195.         ShLeftOr    8
  2196.  
  2197. ; ROL/AND-Gruppe
  2198. RoLeftAnd    MACRO    ;Zyklenzahl
  2199.         move.l    d0,-(sp)
  2200.         ReadByte
  2201.         lsr.b    #1,RP        ;Carry -> X
  2202.         roxl.b    #1,d0
  2203.         move    ccr,RCCR
  2204.         move.b    RCCR,RP        ;Carry holen
  2205.         and.b    d0,RA
  2206.         move    ccr,RCCR    ;N und Z holen
  2207.         move.b    d0,d1
  2208.         move.l    (sp)+,d0
  2209.         WriteByte
  2210.         Next    \1
  2211.         ENDM
  2212.  
  2213. RoLeftAndZero    MACRO    ;Zyklenzahl
  2214.         lea    (RAMPTR,d0.w),a0
  2215.         move.b    (a0),d1
  2216.         lsr.b    #1,RP        ;Carry -> X
  2217.         roxl.b    #1,d1
  2218.         move    ccr,RCCR
  2219.         move.b    RCCR,RP        ;Carry holen
  2220.         and.b    d1,RA
  2221.         move    ccr,RCCR    ;N und Z holen
  2222.         move.b    d1,(a0)
  2223.         cmp.b    #2,d0
  2224.         bhs    \@1$
  2225.         NewConfig
  2226. \@1$        Next    \1
  2227.         ENDM
  2228.  
  2229. RLAZero        ReadAdrZero
  2230.         RoLeftAndZero    5
  2231.  
  2232. RLAZeroX    ReadAdrZeroX
  2233.         RoLeftAndZero    6
  2234.  
  2235. RLAAbs        ReadAdrAbs
  2236.         RoLeftAnd    6
  2237.  
  2238. RLAAbsX        ReadAdrAbsX
  2239.         RoLeftAnd    7
  2240.  
  2241. RLAAbsY        ReadAdrAbsY
  2242.         RoLeftAnd    7
  2243.  
  2244. RLAIndX        ReadAdrIndX
  2245.         RoLeftAnd    8
  2246.  
  2247. RLAIndY        ReadAdrIndY
  2248.         RoLeftAnd    8
  2249.  
  2250. ; LSR/EOR-Gruppe
  2251. ShRightEor    MACRO    ;Zyklenzahl
  2252.         move.l    d0,-(sp)
  2253.         ReadByte
  2254.         lsr.b    #1,d0
  2255.         move    ccr,RCCR
  2256.         move.b    RCCR,RP        ;Carry holen
  2257.         eor.b    d0,RA
  2258.         move.b    d0,d1
  2259.         move.l    (sp)+,d0
  2260.         WriteByte
  2261.         Next    \1
  2262.         ENDM
  2263.  
  2264. ShRightEorZero    MACRO    ;Zyklenzahl
  2265.         lea    (RAMPTR,d0.w),a0
  2266.         move.b    (a0),d1
  2267.         lsr.b    #1,d1
  2268.         move    ccr,RCCR
  2269.         move.b    RCCR,RP        ;Carry holen
  2270.         eor.b    d1,RA
  2271.         move.b    d1,(a0)
  2272.         cmp.b    #2,d0
  2273.         bhs    \@1$
  2274.         NewConfig
  2275. \@1$        Next    \1
  2276.         ENDM
  2277.  
  2278. SREZero        ReadAdrZero
  2279.         ShRightEorZero    5
  2280.  
  2281. SREZeroX    ReadAdrZeroX
  2282.         ShRightEorZero    6
  2283.  
  2284. SREAbs        ReadAdrAbs
  2285.         ShRightEor    6
  2286.  
  2287. SREAbsX        ReadAdrAbsX
  2288.         ShRightEor    7
  2289.  
  2290. SREAbsY        ReadAdrAbsY
  2291.         ShRightEor    7
  2292.  
  2293. SREIndX        ReadAdrIndX
  2294.         ShRightEor    8
  2295.  
  2296. SREIndY        ReadAdrIndY
  2297.         ShRightEor    8
  2298.  
  2299. ; ROR/ADC-Gruppe
  2300. RoRightAdc    MACRO    ;Zyklenzahl
  2301.         move.l    d0,-(sp)
  2302.         ReadByte
  2303.         lsr.b    #1,RP        ;Carry -> X
  2304.         roxr.b    #1,d0
  2305.         move    ccr,RCCR
  2306.         move.b    RCCR,RP        ;Carry holen
  2307.         lsr.b    #1,RP        ;Carry -> X
  2308.         addx.b    d0,RA
  2309.         move    ccr,RCCR
  2310.         bvc    \@2$        ;Overflow holen
  2311.         or.w    #OverflowMask,RP
  2312.         bra    \@3$
  2313. \@2$        and.w    #~OverflowMask,RP
  2314. \@3$        move.b    RCCR,RP        ;Carry holen
  2315.         move.b    d0,d1
  2316.         move.l    (sp)+,d0
  2317.         WriteByte
  2318.         Next    \1
  2319.         ENDM
  2320.  
  2321. RoRightAdcZero    MACRO    ;Zyklenzahl
  2322.         lea    (RAMPTR,d0.w),a0
  2323.         move.b    (a0),d1
  2324.         lsr.b    #1,RP        ;Carry -> X
  2325.         roxr.b    #1,d1
  2326.         move    ccr,RCCR
  2327.         move.b    RCCR,RP        ;Carry holen
  2328.         lsr.b    #1,RP        ;Carry -> X
  2329.         addx.b    d1,RA
  2330.         move    ccr,RCCR
  2331.         bvc    \@2$        ;Overflow holen
  2332.         or.w    #OverflowMask,RP
  2333.         bra    \@3$
  2334. \@2$        and.w    #~OverflowMask,RP
  2335. \@3$        move.b    RCCR,RP        ;Carry holen
  2336.         move.b    d1,(a0)
  2337.         cmp.b    #2,d0
  2338.         bhs    \@1$
  2339.         NewConfig
  2340. \@1$        Next    \1
  2341.         ENDM
  2342.  
  2343. RRAZero        ReadAdrZero
  2344.         RoRightAdcZero    5
  2345.  
  2346. RRAZeroX    ReadAdrZeroX
  2347.         RoRightAdcZero    6
  2348.  
  2349. RRAAbs        ReadAdrAbs
  2350.         RoRightAdc    6
  2351.  
  2352. RRAAbsX        ReadAdrAbsX
  2353.         RoRightAdc    7
  2354.  
  2355. RRAAbsY        ReadAdrAbsY
  2356.         RoRightAdc    7
  2357.  
  2358. RRAIndX        ReadAdrIndX
  2359.         RoRightAdc    8
  2360.  
  2361. RRAIndY        ReadAdrIndY
  2362.         RoRightAdc    8
  2363.  
  2364. ; DEC/CMP-Gruppe
  2365. DecCompare    MACRO    ;Zyklenzahl
  2366.         move.l    d0,-(sp)
  2367.         ReadByte
  2368.         subq.b    #1,d0
  2369.         cmp.b    d0,RA
  2370.         move    ccr,RCCR
  2371.         move.b    RCCR,RP        ;Carry holen und invertieren
  2372.         not.b    RP
  2373.         move.b    d0,d1
  2374.         move.l    (sp)+,d0
  2375.         WriteByte
  2376.         Next    \1
  2377.         ENDM
  2378.  
  2379. DecCompareZero    MACRO    ;Zyklenzahl
  2380.         lea    (RAMPTR,d0.w),a0
  2381.         move.b    (a0),d1
  2382.         subq.b    #1,d1
  2383.         cmp.b    d1,RA
  2384.         move    ccr,RCCR
  2385.         move.b    RCCR,RP        ;Carry holen und invertieren
  2386.         not.b    RP
  2387.         move.b    d1,(a0)
  2388.         cmp.b    #2,d0
  2389.         bhs    \@1$
  2390.         NewConfig
  2391. \@1$        Next    \1
  2392.         ENDM
  2393.  
  2394. DCPZero        ReadAdrZero
  2395.         DecCompareZero    5
  2396.  
  2397. DCPZeroX    ReadAdrZeroX
  2398.         DecCompareZero    6
  2399.  
  2400. DCPAbs        ReadAdrAbs
  2401.         DecCompare    6
  2402.  
  2403. DCPAbsX        ReadAdrAbsX
  2404.         DecCompare    7
  2405.  
  2406. DCPAbsY        ReadAdrAbsY
  2407.         DecCompare    7
  2408.  
  2409. DCPIndX        ReadAdrIndX
  2410.         DecCompare    8
  2411.  
  2412. DCPIndY        ReadAdrIndY
  2413.         DecCompare    8
  2414.  
  2415. ; INC/SBC-Gruppe
  2416. IncSbc        MACRO    ;Zyklenzahl
  2417.         move.l    d0,-(sp)
  2418.         ReadByte
  2419.         addq.b    #1,d0
  2420.         not.b    RP
  2421.         lsr.b    #1,RP        ;Carry invertieren und nach X
  2422.         subx.b    d0,RA
  2423.         move    ccr,RCCR
  2424.         bvc    \@2$        ;Overflow holen
  2425.         or.w    #OverflowMask,RP
  2426.         bra    \@3$
  2427. \@2$        and.w    #~OverflowMask,RP
  2428. \@3$        move.b    RCCR,RP        ;Carry holen und invertieren
  2429.         not.b    RP
  2430.         move.b    d0,d1
  2431.         move.l    (sp)+,d0
  2432.         WriteByte
  2433.         Next    \1
  2434.         ENDM
  2435.  
  2436. IncSbcZero    MACRO    ;Zyklenzahl
  2437.         lea    (RAMPTR,d0.w),a0
  2438.         move.b    (a0),d1
  2439.         addq.b    #1,d1
  2440.         not.b    RP
  2441.         lsr.b    #1,RP        ;Carry invertieren und nach X
  2442.         subx.b    d1,RA
  2443.         move    ccr,RCCR
  2444.         bvc    \@2$        ;Overflow holen
  2445.         or.w    #OverflowMask,RP
  2446.         bra    \@3$
  2447. \@2$        and.w    #~OverflowMask,RP
  2448. \@3$        move.b    RCCR,RP        ;Carry holen und invertieren
  2449.         not.b    RP
  2450.         move.b    d1,(a0)
  2451.         cmp.b    #2,d0
  2452.         bhs    \@1$
  2453.         NewConfig
  2454. \@1$        Next    \1
  2455.         ENDM
  2456.  
  2457. ISBZero        ReadAdrZero
  2458.         IncSbcZero    5
  2459.  
  2460. ISBZeroX    ReadAdrZeroX
  2461.         IncSbcZero    6
  2462.  
  2463. ISBAbs        ReadAdrAbs
  2464.         IncSbc    6
  2465.  
  2466. ISBAbsX        ReadAdrAbsX
  2467.         IncSbc    7
  2468.  
  2469. ISBAbsY        ReadAdrAbsY
  2470.         IncSbc    7
  2471.  
  2472. ISBIndX        ReadAdrIndX
  2473.         IncSbc    8
  2474.  
  2475. ISBIndY        ReadAdrIndY
  2476.         IncSbc    8
  2477.  
  2478. ; Komplexe (undokumentierte) Funktionen
  2479. ANCImm        and.b    (RPC)+,RA    ;??? ($0b, $2b)
  2480.         move    ccr,RCCR
  2481.         smi.b    RP        ;N -> C
  2482.         Next    2
  2483.  
  2484. ASRImm        and.b    (RPC)+,RA
  2485.         lsr.b    #1,RA
  2486.         move    ccr,RCCR
  2487.         move.b    RCCR,RP
  2488.         Next    2
  2489.  
  2490. ARRImm        and.b    (RPC)+,RA
  2491.         lsr.b    #1,RP        ;Carry -> X
  2492.         roxr.b    #1,RA
  2493.         move    ccr,RCCR
  2494.         move.b    RCCR,RP        ;Carry holen
  2495.         Next    2
  2496.  
  2497. ANEImm        or.b    #$ee,RA
  2498.         and.b    (RPC)+,RA
  2499.         and.b    RX,RA
  2500.         move    ccr,RCCR
  2501.         Next    2
  2502.  
  2503. LXAImm        and.b    (RPC)+,RA
  2504.         move.b    RA,RX
  2505.         move    ccr,RCCR
  2506.         Next    2
  2507.  
  2508. LASAbsY        ReadByteAbsY        ;??? ($bb)
  2509.         and.b    RS,d0
  2510.         move.b    d0,RX
  2511.         move.b    d0,RA
  2512.         move    ccr,RCCR
  2513.         Next    4
  2514.  
  2515. SHAAbsY        ReadPCWord
  2516.         move.w    d0,d1
  2517.         lsr.w    #8,d1
  2518.         addq.b    #1,d1
  2519.         and.b    RX,d1
  2520.         and.b    RA,d1
  2521.         add.w    RY,d0
  2522.         WriteByte
  2523.         Next    5
  2524.  
  2525. SHAIndY        moveq    #0,d0
  2526.         move.b    (RPC)+,d0
  2527.         move.w    (RAMPTR,d0.w),d0    ;(Abgekürzt)
  2528.         rol.w    #8,d0            ;Geht bei ($ff),y schief
  2529.         move.w    d0,d1
  2530.         lsr.w    #8,d1
  2531.         addq.b    #1,d1
  2532.         and.b    RX,d1
  2533.         and.b    RA,d1
  2534.         add.w    RY,d0
  2535.         WriteByte
  2536.         Next    6
  2537.  
  2538. SHXAbsY        ReadPCWord
  2539.         move.w    d0,d1
  2540.         lsr.w    #8,d1
  2541.         addq.b    #1,d1
  2542.         and.b    RY,d1
  2543.         add.w    RY,d0
  2544.         WriteByte
  2545.         Next    5
  2546.  
  2547. SHYAbsX        ReadPCWord
  2548.         move.w    d0,d1
  2549.         lsr.w    #8,d1
  2550.         addq.b    #1,d1
  2551.         and.b    RX,d1
  2552.         add.w    RX,d0
  2553.         WriteByte
  2554.         Next    5
  2555.  
  2556. SHSAbsY        move.b    RA,RS
  2557.         and.b    RX,RS
  2558.         ReadPCWord
  2559.         move.w    d0,d1
  2560.         lsr.w    #8,d1
  2561.         addq.b    #1,d1
  2562.         and.b    RS,d1
  2563.         WriteByte
  2564.         Next    5
  2565.  
  2566. SBXImm        and.b    RA,RX
  2567.         sub.b    (RPC)+,RX
  2568.         move    ccr,RCCR
  2569.         move.b    RCCR,RP        ;Carry holen und invertieren
  2570.         not.b    RP
  2571.         Next    2
  2572.  
  2573. *
  2574. * Patches
  2575. *
  2576.  
  2577. OpIEC        move.w    #-1,DontPause    ;Nicht hier anhalten
  2578.         move.b    (RPC)+,d0    ;Selektor holen
  2579.         beq    OpIECOut
  2580.         cmp.b    #1,d0
  2581.         beq    OpIECOutATN
  2582.         cmp.b    #2,d0
  2583.         beq    OpIECOutSec
  2584.         cmp.b    #3,d0
  2585.         beq    OpIECIn
  2586.         cmp.b    #4,d0
  2587.         beq    OpIECSetATN
  2588.         cmp.b    #5,d0
  2589.         beq    OpIECRelATN
  2590.         cmp.b    #6,d0
  2591.         beq    OpIECTurnaround
  2592.         cmp.b    #7,d0
  2593.         beq    OpIECRelease
  2594.         clr.w    DontPause
  2595.         Next    0
  2596.  
  2597. OpIECOut    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2598.         move.b    $a3(RAMPTR),d1    ;EOI-Flag holen
  2599.         bsr    IECOut
  2600.         bra    IECSetST
  2601.  
  2602. OpIECOutATN    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2603.         bsr    IECOutATN
  2604.         bra    IECSetST
  2605.  
  2606. OpIECOutSec    move.b    $95(RAMPTR),d0    ;Auszugebendes Byte holen
  2607.         bsr    IECOutSec
  2608.         bra    IECSetST
  2609.  
  2610. OpIECIn        bsr    IECIn
  2611.         move.b    d1,RA        ;Byte in den Akku
  2612.         move    ccr,RCCR    ;Flags entsprechend setzen
  2613.         bra    IECSetST
  2614.  
  2615. OpIECSetATN    bsr    IECSetATN
  2616.         moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2617.         moveq    #0,d1
  2618.         clr.w    DontPause
  2619.         move.w    #$edfb,d0    ;Nach $edfb springen
  2620.         Jump
  2621.         Next    0
  2622.  
  2623. OpIECRelATN    bsr    IECRelATN
  2624.         bra    IECReturn
  2625.  
  2626. OpIECTurnaround    bsr    IECTurnaround
  2627.         bra    IECReturn
  2628.  
  2629. OpIECRelease    bsr    IECRelease
  2630.         bra    IECReturn
  2631.  
  2632. IECSetST    or.b    d0,$90(RAMPTR)    ;Status setzen
  2633.         clr.b    RP        ;Carry löschen
  2634. IECReturn    moveq    #0,d0        ;MSWs von d0 und d1 löschen
  2635.         moveq    #0,d1
  2636.         clr.w    DontPause
  2637.         bra    RTSImpl        ;RTS ausführen
  2638.  
  2639.  
  2640. **
  2641. ** Konstanten
  2642. **
  2643.  
  2644. ; Strings
  2645. CPUTaskName    dc.b    "6510",0
  2646. TimerIntName    dc.b    "Frodo Timer Int",0
  2647. ReqTitle    dc.b    "Frodo C64 Emulator",0
  2648. ReqGads2    dc.b    "Reset|Na und?",0
  2649. ReqGads        dc.b    "Reset",0
  2650. IllegalOpTxt    dc.b    "Unbekannter Opcode %02x, PC %04x",0
  2651. JumpToIOTxt    dc.b    "Sprung in den I/O-Bereich, PC %04x",0
  2652.  
  2653. IDString    dc.b    "FRODO V1.0",13
  2654.         dc.b    "(C)1994-1995 CHRISTIAN BAUER",0
  2655.         ds.b    64    ;Muß mind. 92 Zeichen lang sein
  2656.         CNOP    0,4
  2657.  
  2658.  
  2659. *
  2660. * Speicherkonfigurationstabelle
  2661. *
  2662.  
  2663. ; Diese Tabelle enthält für alle 8 Speicherkonfigurationen
  2664. ; die Zeiger auf die zugehörigen Read- und WriteTabs
  2665.         CNOP    0,4
  2666. ConfigTab    dc.l    ReadTab0,WriteTab0
  2667.         dc.l    ReadTab1,WriteTab1
  2668.         dc.l    ReadTab2,WriteTab2
  2669.         dc.l    ReadTab3,WriteTab3
  2670.         dc.l    ReadTab4,WriteTab4
  2671.         dc.l    ReadTab5,WriteTab5
  2672.         dc.l    ReadTab6,WriteTab6
  2673.         dc.l    ReadTab7,WriteTab7
  2674.  
  2675.  
  2676. *
  2677. * Opcode Dispatch Table
  2678. * "*" bezeichnet einen undokumentierten Opcode
  2679. *
  2680.  
  2681.         CNOP    0,4
  2682. OpcodeTable
  2683. CyclesLeft    dc.w    0    ;Anzahl zur Verfügung stehender CPU-Zyklen
  2684.                 ; bis zum nächsten Periodic
  2685.         dc.w    0
  2686.         dc.l    BRK        ;$00
  2687.         dc.l    ORAIndX
  2688.         dc.l    IllegalOp
  2689.         dc.l    SLOIndX        ;*
  2690.         dc.l    NOPZero        ;*
  2691.         dc.l    ORAZero
  2692.         dc.l    ASLZero
  2693.         dc.l    SLOZero        ;*
  2694.  
  2695.         dc.l    PHP        ;$08
  2696.         dc.l    ORAImm
  2697.         dc.l    ASLA
  2698.         dc.l    ANCImm        ;*
  2699.         dc.l    NOPAbs        ;*
  2700.         dc.l    ORAAbs
  2701.         dc.l    ASLAbs
  2702.         dc.l    SLOAbs        ;*
  2703.  
  2704.         dc.l    BPLRel        ;$10
  2705.         dc.l    ORAIndY
  2706.         dc.l    IllegalOp
  2707.         dc.l    SLOIndY        ;*
  2708.         dc.l    NOPZeroX    ;*
  2709.         dc.l    ORAZeroX
  2710.         dc.l    ASLZeroX
  2711.         dc.l    SLOZeroX    ;*
  2712.  
  2713.         dc.l    CLC        ;$18
  2714.         dc.l    ORAAbsY
  2715.         dc.l    NOPImpl        ;*
  2716.         dc.l    SLOAbsY        ;*
  2717.         dc.l    NOPAbsX        ;*
  2718.         dc.l    ORAAbsX
  2719.         dc.l    ASLAbsX
  2720.         dc.l    SLOAbsX
  2721.  
  2722.         dc.l    JSRAbs        ;$20
  2723.         dc.l    ANDIndX
  2724.         dc.l    IllegalOp
  2725.         dc.l    RLAIndX        ;*
  2726.         dc.l    BITZero
  2727.         dc.l    ANDZero
  2728.         dc.l    ROLZero
  2729.         dc.l    RLAZero        ;*
  2730.  
  2731.         dc.l    PLP        ;$28
  2732.         dc.l    ANDImm
  2733.         dc.l    ROLA
  2734.         dc.l    ANCImm        ;*
  2735.         dc.l    BITAbs
  2736.         dc.l    ANDAbs
  2737.         dc.l    ROLAbs
  2738.         dc.l    RLAAbs        ;*
  2739.  
  2740.         dc.l    BMIRel        ;$30
  2741.         dc.l    ANDIndY
  2742.         dc.l    IllegalOp
  2743.         dc.l    RLAIndY        ;*
  2744.         dc.l    NOPZeroX    ;*
  2745.         dc.l    ANDZeroX
  2746.         dc.l    ROLZeroX
  2747.         dc.l    RLAZeroX    ;*
  2748.  
  2749.         dc.l    SEC        ;$38
  2750.         dc.l    ANDAbsY
  2751.         dc.l    NOPImpl        ;*
  2752.         dc.l    RLAAbsY        ;*
  2753.         dc.l    NOPAbsX        ;*
  2754.         dc.l    ANDAbsX
  2755.         dc.l    ROLAbsX
  2756.         dc.l    RLAAbsX        ;*
  2757.  
  2758.         dc.l    RTIImpl        ;$40
  2759.         dc.l    EORIndX
  2760.         dc.l    IllegalOp
  2761.         dc.l    SREIndX        ;*
  2762.         dc.l    NOPZero        ;*
  2763.         dc.l    EORZero
  2764.         dc.l    LSRZero
  2765.         dc.l    SREZero        ;*
  2766.  
  2767.         dc.l    PHA        ;$48
  2768.         dc.l    EORImm
  2769.         dc.l    LSRA
  2770.         dc.l    ASRImm        ;*
  2771.         dc.l    JMPAbs
  2772.         dc.l    EORAbs
  2773.         dc.l    LSRAbs
  2774.         dc.l    SREAbs        ;*
  2775.  
  2776.         dc.l    BVCRel        ;$50
  2777.         dc.l    EORIndY
  2778.         dc.l    IllegalOp
  2779.         dc.l    SREIndY        ;*
  2780.         dc.l    NOPZeroX    ;*
  2781.         dc.l    EORZeroX
  2782.         dc.l    LSRZeroX
  2783.         dc.l    SREZeroX    ;*
  2784.  
  2785.         dc.l    CLI        ;$58
  2786.         dc.l    EORAbsY
  2787.         dc.l    NOPImpl        ;*
  2788.         dc.l    SREAbsY        ;*
  2789.         dc.l    NOPAbsX        ;*
  2790.         dc.l    EORAbsX
  2791.         dc.l    LSRAbsX
  2792.         dc.l    SREAbsX        ;*
  2793.  
  2794.         dc.l    RTSImpl        ;$60
  2795.         dc.l    ADCIndX
  2796.         dc.l    IllegalOp
  2797.         dc.l    RRAIndX        ;*
  2798.         dc.l    NOPZero        ;*
  2799.         dc.l    ADCZero
  2800.         dc.l    RORZero
  2801.         dc.l    RRAZero        ;*
  2802.  
  2803.         dc.l    PLA        ;$68
  2804.         dc.l    ADCImm
  2805.         dc.l    RORA
  2806.         dc.l    ARRImm        ;*
  2807.         dc.l    JMPInd
  2808.         dc.l    ADCAbs
  2809.         dc.l    RORAbs
  2810.         dc.l    RRAAbs        ;*
  2811.  
  2812.         dc.l    BVSRel        ;$70
  2813.         dc.l    ADCIndY
  2814.         dc.l    IllegalOp
  2815.         dc.l    RRAIndY        ;*
  2816.         dc.l    NOPZeroX    ;*
  2817.         dc.l    ADCZeroX
  2818.         dc.l    RORZeroX
  2819.         dc.l    RRAZeroX    ;*
  2820.  
  2821.         dc.l    SEI        ;$78
  2822.         dc.l    ADCAbsY
  2823.         dc.l    NOPImpl        ;*
  2824.         dc.l    RRAAbsY        ;*
  2825.         dc.l    NOPAbsX        ;*
  2826.         dc.l    ADCAbsX
  2827.         dc.l    RORAbsX
  2828.         dc.l    RRAAbsX        ;*
  2829.  
  2830.         dc.l    NOPZero        ;* $80
  2831.         dc.l    STAIndX
  2832.         dc.l    NOPZero        ;*
  2833.         dc.l    SAXIndX        ;*
  2834.         dc.l    STYZero
  2835.         dc.l    STAZero
  2836.         dc.l    STXZero
  2837.         dc.l    SAXZero        ;*
  2838.  
  2839.         dc.l    DEY        ;$88
  2840.         dc.l    NOPZero        ;*
  2841.         dc.l    TXA
  2842.         dc.l    ANEImm        ;*
  2843.         dc.l    STYAbs
  2844.         dc.l    STAAbs
  2845.         dc.l    STXAbs
  2846.         dc.l    SAXAbs        ;*
  2847.  
  2848.         dc.l    BCCRel        ;$90
  2849.         dc.l    STAIndY
  2850.         dc.l    IllegalOp
  2851.         dc.l    SHAIndY        ;*
  2852.         dc.l    STYZeroX
  2853.         dc.l    STAZeroX
  2854.         dc.l    STXZeroY
  2855.         dc.l    SAXZeroY    ;*
  2856.  
  2857.         dc.l    TYA        ;$98
  2858.         dc.l    STAAbsY
  2859.         dc.l    TXS
  2860.         dc.l    SHSAbsY        ;*
  2861.         dc.l    SHYAbsX        ;*
  2862.         dc.l    STAAbsX
  2863.         dc.l    SHXAbsY        ;*
  2864.         dc.l    SHAAbsY        ;*
  2865.  
  2866.         dc.l    LDYImm        ;$a0
  2867.         dc.l    LDAIndX
  2868.         dc.l    LDXImm
  2869.         dc.l    LAXIndX        ;*
  2870.         dc.l    LDYZero
  2871.         dc.l    LDAZero
  2872.         dc.l    LDXZero
  2873.         dc.l    LAXZero        ;*
  2874.  
  2875.         dc.l    TAY        ;$a8
  2876.         dc.l    LDAImm
  2877.         dc.l    TAX
  2878.         dc.l    LXAImm        ;*
  2879.         dc.l    LDYAbs
  2880.         dc.l    LDAAbs
  2881.         dc.l    LDXAbs
  2882.         dc.l    LAXAbs        ;*
  2883.  
  2884.         dc.l    BCSRel        ;$b0
  2885.         dc.l    LDAIndY
  2886.         dc.l    IllegalOp
  2887.         dc.l    LAXIndY        ;*
  2888.         dc.l    LDYZeroX
  2889.         dc.l    LDAZeroX
  2890.         dc.l    LDXZeroY
  2891.         dc.l    LAXZeroY    ;*
  2892.  
  2893.         dc.l    CLV        ;$b8
  2894.         dc.l    LDAAbsY
  2895.         dc.l    TSX
  2896.         dc.l    LASAbsY        ;*
  2897.         dc.l    LDYAbsX
  2898.         dc.l    LDAAbsX
  2899.         dc.l    LDXAbsY
  2900.         dc.l    LAXAbsY        ;*
  2901.  
  2902.         dc.l    CPYImm        ;$c0
  2903.         dc.l    CMPIndX
  2904.         dc.l    NOPZero        ;*
  2905.         dc.l    DCPIndX        ;*
  2906.         dc.l    CPYZero
  2907.         dc.l    CMPZero
  2908.         dc.l    DECZero
  2909.         dc.l    DCPZero        ;*
  2910.  
  2911.         dc.l    INY        ;$c8
  2912.         dc.l    CMPImm
  2913.         dc.l    DEX
  2914.         dc.l    SBXImm        ;*
  2915.         dc.l    CPYAbs
  2916.         dc.l    CMPAbs
  2917.         dc.l    DECAbs
  2918.         dc.l    DCPAbs        ;*
  2919.  
  2920.         dc.l    BNERel        ;$d0
  2921.         dc.l    CMPIndY
  2922.         dc.l    IllegalOp
  2923.         dc.l    DCPIndY        ;*
  2924.         dc.l    NOPZeroX    ;*
  2925.         dc.l    CMPZeroX
  2926.         dc.l    DECZeroX
  2927.         dc.l    DCPZeroX    ;*
  2928.  
  2929.         dc.l    CLD        ;$d8
  2930.         dc.l    CMPAbsY
  2931.         dc.l    NOPImpl        ;*
  2932.         dc.l    DCPAbsY        ;*
  2933.         dc.l    NOPAbsX        ;*
  2934.         dc.l    CMPAbsX
  2935.         dc.l    DECAbsX
  2936.         dc.l    DCPAbsX        ;*
  2937.  
  2938.         dc.l    CPXImm        ;$e0
  2939.         dc.l    SBCIndX
  2940.         dc.l    NOPZero        ;*
  2941.         dc.l    ISBIndX        ;*
  2942.         dc.l    CPXZero
  2943.         dc.l    SBCZero
  2944.         dc.l    INCZero
  2945.         dc.l    ISBZero        ;*
  2946.  
  2947.         dc.l    INX        ;$e8
  2948.         dc.l    SBCImm
  2949.         dc.l    NOPImpl
  2950.         dc.l    SBCImm        ;*
  2951.         dc.l    CPXAbs
  2952.         dc.l    SBCAbs
  2953.         dc.l    INCAbs
  2954.         dc.l    ISBAbs        ;*
  2955.  
  2956.         dc.l    BEQRel        ;$f0
  2957.         dc.l    SBCIndY
  2958.         dc.l    OpIEC        ;Patch
  2959.         dc.l    ISBIndY        ;*
  2960.         dc.l    NOPZeroX    ;*
  2961.         dc.l    SBCZeroX
  2962.         dc.l    INCZeroX
  2963.         dc.l    ISBZeroX    ;*
  2964.  
  2965.         dc.l    SED        ;$f8
  2966.         dc.l    SBCAbsY
  2967.         dc.l    NOPImpl        ;*
  2968.         dc.l    ISBAbsY        ;*
  2969.         dc.l    NOPAbsX        ;*
  2970.         dc.l    SBCAbsX
  2971.         dc.l    INCAbsX
  2972.         dc.l    ISBAbsX        ;*
  2973.  
  2974.  
  2975. **
  2976. ** Datenbereich
  2977. **
  2978.  
  2979. ; 6510-Task
  2980. CPUProc        dc.l    0    ;Prozess-Handle
  2981. CPUTask        dc.l    0    ;Task des Prozesses
  2982. ReadySet    dc.l    0    ;Signal des Hauptprogramms
  2983. ReadySig    dc.w    0
  2984. DontPause    dc.w    0    ;#0: Task darf nicht angehalten werden
  2985.  
  2986. ; Emulator-Kennung
  2987. DFFFByte    dc.b    $55    ;Wechselt bei jedem Lesen zwischen $55 und $aa
  2988.  
  2989. ; Interrupt-Flags. Bei einem Interrupt wird eins dieser Flags gesetzt.
  2990. ; Das bewirkt, daß nach dem nächsten Periodic der 6510-Task in die
  2991. ; Routine "HandleInt" springt. Dort werden diese Flags ausgewertet und
  2992. ; entsprechend verzweigt.
  2993.         CNOP    0,4
  2994. Interrupt            ;Zusammenfassung als Langwort
  2995. IntIsRESET    dc.b    0    ;RESET aufgetreten oder 6510 beenden
  2996. IntIsNMI    dc.b    0    ;NMI aufgetreten
  2997. IntIsIRQ            ;Zusammenfassung als Wort
  2998. IntIsVICIRQ    dc.b    0    ;IRQ durch VIC aufgetreten
  2999. IntIsCIAIRQ    dc.b    0    ;IRQ durch CIA-A aufgetreten
  3000.  
  3001. RESETIsEXIT    dc.b    0    ;Zu Unterscheidung von RESET und EXIT
  3002.  
  3003. ; Speicherzeiger (außer bei TheChar stimmt bei allen das untere Wort
  3004. ; mit der tatsächlichen C64-Adresse überein, also
  3005. ;  TheRAM   : xxxx0000
  3006. ;  TheBasic : xxxxa000
  3007. ;  TheKernal: xxxxe000
  3008. ;  TheColor : xxxxd800
  3009.         CNOP    0,4
  3010. TheRAM        dc.l    0    ;Zeiger auf C64-RAM (64K)
  3011. TheBasic    dc.l    0    ;Zeiger auf Basic-ROM
  3012. TheKernal    dc.l    0    ;Zeiger auf Kernal-ROM
  3013. TheChar        dc.l    0    ;Zeiger auf Char-ROM
  3014. TheColor    dc.l    0    ;Zeiger auf Farb-RAM
  3015.  
  3016. ; Taglist für CreateNewProc
  3017. ProcTags    dc.l    NP_Entry,CPUTaskProc
  3018.         dc.l    NP_Name,CPUTaskName
  3019.         dc.l    NP_Priority,-1
  3020.         dc.l    0,0
  3021.  
  3022. ; Requester
  3023. IllegalOpReq    dc.l    20,0    
  3024.         dc.l    ReqTitle
  3025.         dc.l    IllegalOpTxt
  3026.         dc.l    ReqGads2
  3027. JumpToIOReq    dc.l    20,0
  3028.         dc.l    ReqTitle
  3029.         dc.l    JumpToIOTxt
  3030.         dc.l    ReqGads
  3031.  
  3032. RequestStream    ds.l    16    ;Argumente
  3033.  
  3034.         SECTION    "BSS",BSS
  3035.  
  3036. ; Sprungtabellen für Speicherzugriff: Ein Eintrag pro Seite
  3037. ; Eine Tabelle für jede der 8 Speicherkonfigurationen
  3038. ReadTab0    ds.l    256
  3039. ReadTab1    ds.l    256
  3040. ReadTab2    ds.l    256
  3041. ReadTab3    ds.l    256
  3042. ReadTab4    ds.l    256
  3043. ReadTab5    ds.l    256
  3044. ReadTab6    ds.l    256
  3045. ReadTab7    ds.l    256
  3046.  
  3047. WriteTab0    ds.l    256
  3048. WriteTab1    ds.l    256
  3049. WriteTab2    ds.l    256
  3050. WriteTab3    ds.l    256
  3051. WriteTab4    ds.l    256
  3052. WriteTab5    ds.l    256
  3053. WriteTab6    ds.l    256
  3054. WriteTab7    ds.l    256
  3055.  
  3056. JumpTab0    ds.l    256
  3057. JumpTab1    ds.l    256
  3058. JumpTab2    ds.l    256
  3059. JumpTab3    ds.l    256
  3060. JumpTab4    ds.l    256
  3061. JumpTab5    ds.l    256
  3062. JumpTab6    ds.l    256
  3063. JumpTab7    ds.l    256
  3064.  
  3065.         END
  3066.